#include <boost/preprocessor/seq/for_each_product.hpp>
#include <boost/preprocessor/seq/enum.hpp>

#define S1 (NoHide)(TimeoutHidding)(CHP)
#define S2 (NoDefense)(BulletProofed)(ShellProofed)
#define S3 (Movable)(Stationary)
// etc.

#define REGISTER(r, policies) \
  factory->subscribe(Radar<BOOST_PP_SEQ_ENUM(policies)>::ID(), \
                     createInstance<IRadar, Radar<BOOST_PP_SEQ_ENUM(policies)> >);

BOOST_PP_SEQ_FOR_EACH_PRODUCT(REGISTER, (S1)(S2)(S3)/*etc.*/)

#include "loki/Factory.h"
#include "loki/Singleton.h"
#include "loki/static_check.h"
#include "loki/TypeManip.h"

template
<
  class AbstractClass, 
  class ConcreteClass,
  class FactoryIDType
>
class FactoryCreatablePolicy
{
public:
  static AbstractClass* Create()
  {
    // Verify that the given types are 
    // actually super and sub classes
    LOKI_STATIC_CHECK( 
      LOKI_SUPERSUBCLASS( AbstractClass, ConcreteClass ), 
      types_are_not_super_and_subclass );

    return new ConcreteClass;
  }

  // Method to allow non-conformant compilers
  // to manually register with the factory.
  // Only needed as a work-around.
  static bool IsRegistered() 
  { return registered_; }

protected:
  // Protected ctor and dtor so base classes
  // can use this as a policy
  FactoryCreatablePolicy() {}

  // "virtual" is required because otherwise the compiler
  // may optimize this away, subverting the trick described
  // below.
  virtual ~FactoryCreatablePolicy() 
  { 
    // In order to automatically register with 
    // the factory any subclass that uses this
    // class as a policy, we must force the
    // instantiation of the static member 
    // registered_. Otherwise, it will not be
    // instantiated unless the program explicitly 
    // references it somewhere, which is an 
    // inconvenient requirement. This way it will 
    // always be instantiated on a standard-
    // conformant compiler.

    (void)&registered_;
  }

private:
  // This typedef would need to be expanded to 
  // include all other factory parameters. It is 
  // reduced here for the sake of simplicity of 
  // presentation.

  typedef Loki::SingletonHolder
  < 
    Loki::Factory
    <
      AbstractClass, 
      FactoryIDType
    > 
  > theFactory;
  
  static const volatile bool registered_;
};

// Register all our factory-creatable classes 
// with their respective factories. (Note that 
// these static members appear in the header file 
// because they are themselves templates. The
// compiler will ensure that there is only one
// instance of each globally.)
template
<
  class AbstractClass, 
  class ConcreteClass,
  class FactoryIDType
>
const volatile bool 
  FactoryCreatablePolicy<AbstractClass, ConcreteClass, FactoryIDType>::registered_ = 
    theFactory::Instance().Register( 
      ConcreteClass::FACTORY_ID, 
      Create );

struct Base 
{ 
  virtual ~Base() {}
};

struct Derived1
  : Base
  , FactoryCreatablePolicy<Base,Derived1,int>
{
  enum { FACTORY_ID = 1 };
};

struct Derived2
  : Base
  , FactoryCreatablePolicy<Base,Derived2,int>
{
  enum { FACTORY_ID = 2 };
};

typedef Loki::Factory<Base, int> BaseFactory;
typedef Loki::SingletonHolder< BaseFactory > theBaseFactory;

int main()
{
  BaseFactory& factory = 
    theBaseFactory::Instance();

  try
  {
    auto_ptr<Base> b1( factory.CreateObject( Derived1::FACTORY_ID ) );
    auto_ptr<Base> b2( factory.CreateObject( Derived2::FACTORY_ID ) );

    // ...

    cout << "Successful creation of objects." << endl;
  }
  catch( const exception& e )
  {
    cerr << e.what() << endl;
    return -1;
  }
}