Question

I am designing an application, where multiple geometric primitive types (all inheriting the base Primitive class) are stored in an object of class Scene.

Instead of having a function in my main() that programmatically creates a scene by constructing the primitives and then calling Scene::add(...), I’d like to have some sort of configuration file that is read at runtime.
This would save me from having to recompile every time I change something about the scene, and seems like a general good idea (in case someone else that can’t program might need to use my program sometime)

I’ve devised a little scheme that defines the scene through a .ini file like so:

[primitivefoo]
type = sphere
pos = 10 20 30
radius = 5.5

[primitivebar]
type = triangle
vertexA = 10 10 -10
vertexB = ...
...

You get the idea.

My plan is to have each subclass of Primitive register their own method interpretINI(...) in the class Scene. Scene would need some sort of map that maps string->void* (...), so that I know which type-string from the .ini file corresponds to which subclass of Primitive.

If this entire approach is bad design, and there is already a much more elegant way to achieve what I want to achieve, I would love to hear it. If not, I would be very grateful if someone could help me realize my design. I’m stuck on how to iterate over all Primitive subclasses to have them register themselves in Scene…

Answer 1

Your approach sounds good to me, with the exception that the names should map to a function returning Primitive* (instead of void*). This is a factory pattern (on two levels)

One limitation of this approach is that the factory functions registered will have to accept the same number/type of parameters. [Update: upon reading your comment to your question, this should not be a problem in your case].

I do not know of any automatic way of enumerating subclasses of a particular class, you will need to manually register the known classes (in main, or a special register function)

Update: you could get around the subclass enumeration by using static variables (in-class or otherwise) that will run a “register” function specific to the class-in-question:

class MyShape : public Shape
{
  static int reg;
  // appropriate constructor
};

int registerMyShape();

int MyShape::reg = registerMyShape(); // this will be called at program startup

The only problem is, there is no guarantee about the static initialization order in separate compilation units. Maybe if you can make the shapes module-like and “load” them after the registry class is fully initialized?