Maintainability of library in C++ - c++

Question

I am creating a library in C++ with the intent of utilizing it in future applications (games). I decided on using an Entity-Property design where a base entity can be extended by attaching various properties to it. Properties are all derivatives of a base GameProperty class which allows them to be stored in a single vector of polymorphic pointers, which is a member of the GameEntity class. I have an EntityManager class which creates specialized entities by attaching the correct set of properties to them, in accordance with an EntityTemplate that can be loaded from file.
Here is the problem: I want it to be easy to create and add new properties to suit the needs of a given project. But each new property cannot simply extend GameProperty, it needs to as seemlessly as possible be integratable into the EntityManager. The EntityManager expects strings like "GraphicsProperty", "InputProperty", etc and then selects which property to attach to newly created entities based on that. How can I structure the Property and EntityManager classes in such a way that typespecific code does not need to be added to EntityManager for each new Property I write?
Consider the example below:
class GameProperty
{
virtual void Update() = 0;
};
class GraphicsProperty : public GameProperty
{
void Update();
};
class InputProperty : public GameProperty
{
void Update();
};
class GameEntity
{
public:
void AttachProperty(shared_ptr<GameProperty> newProperty)
{
properties.push_back(newProperty);
};
vector<shared_ptr<GameProperty>> properties;
};
class EntityTemplate
{
public:
vector<string> properties;
};
class EntityManager
{
public:
std::shared_ptr<GameEntity>
EntityManager::CreateEntityFromTemplate(shared_ptr<EntityTemplate> entityTemplate)
{
std::shared_ptr<GameEntity> newEntity = make_shared<GameEntity>();
for each(string propertyName in entityTemplate->properties)
{
if(propertyName == "GraphicsProperty")
{
shared_ptr<GraphicsProperty> gProperty = make_shared<Graphics::GraphicsProperty>();
newEntity->AttachProperty(gProperty);
}
else if(propertyName == "InputProperty")
{
shared_ptr<Input::InputProperty> iProperty = make_shared<Input::InputProperty>();
newEntity->AttachProperty(iProperty);
}
}
};
};
Not seen above is the EntityLoader that creates EntityTemplate objects from an XML file.

Answer 1

You can register all the properties to construct an array of property factories and use the factories in your entity manager to create them, e.g.
class GamePropertyFactoryBase
{
public:
virtual GameProperty *Create() const=0;
};
template<class T>
class GamePropertyFactory: public GamePropertyFactoryBase
{
public:
virtual GameProperty *Create() const {return new T;}
};
typedef std::pair<const GamePropertyFactoryBase*, const char*> FactoryEntry_t;
std::vector<FactoryEntry_t> s_propertyFactories;
template<class T>
void RegisterProperty(const char *name_)
{
static const GamePropertyFactory<T> s_factory;
s_propertyFactories.push_back(FactoryEntry_t(&s_factory, name_));
}
void RegisterEntities()
{
// register all properties here
RegisterProperty<GraphicsProperty>("GraphicsProperty");
};
Then in the EntityManager search the name from the array and call:
GameProperty *prop=it->first->Create();