Strategy & builder design patterns and templates in C++ - c++

Question

The following is the geometry class, which handles storing and manipulating vertex and index information of a particular 3-dimensional object.
class geometry {
public:
geometry();
~geometry();
unsigned int get_face_count();
unsigned int get_vertex_count();
void add_vertex(vertex v);
void add_face(face f);
void remove_vertex(unsigned int idx);
void remove_face(unsigned int idx);
std::vector<vertex>& get_vdata();
std::vector<face>& get_fdata();
vertex& get_vertex(unsigned int idx);
vertex& get_face(unsigned int idx);
void clear();
void calc_normals();
bool is_empty() const;
protected:
std::vector<vertex> vertices;
std::vector<face> faces;
};
The following is a base Builder class, which can't be instantiated:
class geometry_creator : public geometry {
protected:
bool normalsWerePredefined;
/* Unused */
bool texturesWerePredefined;
public:
geometry* build();
};
The build(); method for all derived Builder classes are the same, which looks like this (for context):
/* Liskov principle (upcasting) */
geometry* geometry_creator::build() {
if (!normalsWerePredefined) calc_normals();
geometry* g = new geometry(*this);
return g;
}
Next is the geometry_obj class, which inherits geometry_creator (Builder). This class is responsible for building a geometry object from a specified .OBJ file. I created a builder class because there exists other ways to build geometry objects, such as procedural methods.
class geometry_obj : public geometry_creator {
private:
std::string filename;
std::fstream file;
std::stringstream stream;
std::string element;
enum entry {
VERTEX,
VERTEX_TEXTURES,
VERTEX_NORMALS,
FACE
};
inline static const std::map<std::string, entry> map = {
{"v", VERTEX},
{"vt", VERTEX_TEXTURES},
{"vn", VERTEX_NORMALS},
{"f", FACE}
};
/* Our strategies. */
vec_strategy<3, float> vec3f_strategy;
vec_strategy<2, float> vec2f_strategy;
vec_strategy<3, unsigned int> vec3i_strategy;
protected:
unsigned int vIndex, vnIndex, vtIndex, fIndex;
public:
geometry_obj(std::string filename);
};
The vec_strategy members give us the context for my question.
Lastly, the next two classes define the interface for a particular Strategy and then the concrete Strategy class.
template<typename T>
/* Strategy interface. */
class objreader_strategy {
public:
virtual T execute(std::stringstream& stream) = 0;
};
/* Concrete strategy implementation. */
/* int L is data length, typename S is datatype of data to acquire. */
template<int L, typename S>
class vec_strategy : objreader_strategy<glm::vec<L, S>>{
private:
std::array<S, L> _data;
public:
vec_strategy();
~vec_strategy() = default;
virtual glm::vec<L, S> execute(std::stringstream& stream);
};
In most Strategy design pattern implementations, the Context (our derived Builder class geometry_obj) has a setStrategy method and executeStrategy method. With this implementation I could not find a way to create a method parameter that could handle a base pointer to obj_strategy for setStrategy nor a way to store a theoretical currentStrategy member, given the relatively complex template parameters.
My question is now: what solution exists to store a currentStrategy object in the given context (templates for T, L, and S)? What better method exists to prevent the instantiation of multiple vec_strategy objects in the geometry_obj class, and instead use one member that certain methods in geometry_obj could act upon when needed?
I have not tested to see if this code runs as expected yet, but it does compile. So part of my question also asks: how well is this program designed? - from your perspective.
If any additional context is required, such as implementation of these classes, I would gladly provide it. I'm also terribly sorry for my naming conventions.