The Registrar Idiom

Goal

To construct/create objects without hard-coding the class name in the code.

Motivation

I heard that this sort of technique was used by the developers of the AS/400 OS to introduce new printer drivers at runtime. One of the complaints of an old version was the length of time required to install new drivers, so when IBM re-wrote the OS in C++ one of the goals was to have a dynamic run time registration system for new hardware drivers. The developers used this idiom to accomplish that requirement.

C++ vs Java

This is much simpler to do in Java with the static code block facility that is executed when the .class file is loaded by the VM. The solution below details how to accomplish this Idiom in C++, doing the same in Java is omitted for brevity.

Solution

• Add a clone() method to all classes (The 'Virtual Copy Constructor?' Idiom)
• Create a Map instance to use as a registry for all the subclasses of Thing
  • This must use 'construct on first use' semantics
  • This should be a static member of the base class, so the Registrar is referenced as Thing::registrar()
• 'Ugly' code can populate the registry with hard-coded or well known subclasses of 'Thing' as follows
  

  
  Thing::registrar()["ThingA"] = new ThingA();
  Thing::registrar()["ThingB"] = new ThingB();
  ... (one per derived class)
  



• The original goal is achieved as now the following works:
  

  
  String className = ...;
  Thing *t = Thing.getThing(className);
  
  where
  
  Thing* Thing::getThing(String className)
  {
   return Thing::registrar()[className]->clone();
  }
  



• OPTIONAL:
  
  • Use the constructor of a static object in the derived class to populate the registry
  
  
  • If the registry doesn't contain className, then getThing can try to dynamically load a library that could contain the new derived class and then retry querying the registry.
  
  

Example

Shape.h

class Shape
{
public:
  ...
  virtual Shape* clone() const = 0;
  Shape* getShape(String& name);
  ...

protected:
  ...
  static Map& registrar();
  ...
  class Registrarer {
    public:
       Registrarer(String className, Shape* prototype);
  };
  ...

private:
  ...
};

Shape.cpp

Map& Shape::registrar()
{
 static Map* registry = new Map;
 return *registry;
}

Shape* Shape::getShape(String& name)
{
 if (!registrar().containsKey(className))
 {
    String DLLName = className + ".DLL";
    // try to load DLL containing the requested shape...
    ...
    if (!registrar().containsKey(className))
       throw Exception("Can't find: " + className);
 }
 return registrar()[className]->clone();
}

...

Shape::Registrarer(String className, Shape* prototype)
{
 Shape::registrar()[className] = prototype;
}

...

Circle.cpp (note no .h is necessary)

class Circle : public Shape
{
public:
 ...
 virtual Shape* clone() const;
 ...

private:
 ...
 static Shape::Registrarer reg_;
 ...
};

// Automatically add myself to the Shape registry
Shape::Registarer Circle::reg_("Circle", new Circle());

...