////////////////////////////////////////////////////////////////////////////////
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// Copyright (c) 2005 by Peter Kuemmel
// This code DOES NOT accompany the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
//
// Code covered by the MIT License
// The authors make no representations about the suitability of this software
// for any purpose. It is provided "as is" without express or implied warranty.
////////////////////////////////////////////////////////////////////////////////
#ifndef LOKI_FACTORYPARM_INC_
#define LOKI_FACTORYPARM_INC_

// $Id: Factory.h 788 2006-11-24 22:30:54Z clitte_bbt $


#include "LokiTypeInfo.h"
#include "Functor.h"
#include "AssocVector.h"
#include "SmallObj.h"
#include "Sequence.h"

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4702)
//unreachable code if OnUnknownType throws an exception
#endif

/**
 * \defgroup	FactoriesGroup Factories
 * \defgroup	FactoryGroup Factory
 * \ingroup		FactoriesGroup
 * \brief		Implements a generic object factory.
 *
 * <i>The Factory Method pattern is an object-oriented design pattern.
 * Like other creational patterns, it deals with the problem of creating objects
 * (products) without specifying the exact class of object that will be created.
 * Factory Method, one of the patterns from the Design Patterns book, handles
 * this problem by defining a separate method for creating the objects, which
 * subclasses can then override to specify the derived type of product that will
 * be created.
 * <br>
 * More generally, the term Factory Method is often used to refer to any method
 * whose main purpose is creation of objects.</i>
 * <div ALIGN="RIGHT"><a href="http://en.wikipedia.org/wiki/Factory_method_pattern">
 * Wikipedia</a></div>
 *
 * Loki proposes a generic version of the Factory. Here is a typical use.<br>
 * <code><br>
 * 1. Factory< AbstractProduct, int > aFactory;<br>
 * 2. aFactory.Register( 1, createProductNull );<br>
 * 3. aFactory.CreateObject( 1 ); <br>
 * </code><br>
 * <br>
 * - 1. The declaration<br>
 * You want a Factory that produces AbstractProduct.<br>
 * The client will refer to a creation method through an int.<br>
 * - 2.The registration<br>
 * The code that will contribute to the Factory will now need to declare its
 * ProductCreator by registering them into the Factory.<br>
 * A ProductCreator is a just a function that will return the right object. ie <br>
 * <code>
 * Product* createProductNull()<br>
 * {<br>
 *     return new Product<br>
 * }<br>
 * </code><br>
 * - 3. The use<br>
 * Now the client can create object by calling the Factory's CreateObject method
 * with the right identifier. If the ProductCreator were to have arguments
 * (<i>ie :Product* createProductParm( int a, int b )</i>)
 */

namespace Loki
{

/**
 * \defgroup	FactoryErrorPoliciesGroup Factory Error Policies
 * \ingroup		FactoryGroup
 * \brief		Manages the "Unknown Type" error in an object factory
 *
 * \class DefaultFactoryError
 * \ingroup		FactoryErrorPoliciesGroup
 * \brief		Default policy that throws an exception
 *
 */

template <typename IdentifierType, class AbstractProduct>
struct DefaultFactoryError
{
    struct Exception : public std::exception
    {
        const char* what() const throw() { return "Unknown Type"; }
    };

    static AbstractProduct* OnUnknownType(IdentifierType)
    {
        throw Exception();
    }
};


#define LOKI_ENABLE_NEW_FACTORY_CODE
#ifdef LOKI_ENABLE_NEW_FACTORY_CODE


////////////////////////////////////////////////////////////////////////////////
// class template FunctorImpl
////////////////////////////////////////////////////////////////////////////////

struct FactoryImplBase
{
    typedef EmptyType Parm1;
    typedef EmptyType Parm2;
    typedef EmptyType Parm3;
    typedef EmptyType Parm4;
    typedef EmptyType Parm5;
    typedef EmptyType Parm6;
    typedef EmptyType Parm7;
    typedef EmptyType Parm8;
    typedef EmptyType Parm9;
    typedef EmptyType Parm10;
    typedef EmptyType Parm11;
    typedef EmptyType Parm12;
    typedef EmptyType Parm13;
    typedef EmptyType Parm14;
    typedef EmptyType Parm15;
};

template <typename AP, typename Id, typename TList >
struct FactoryImpl;

template<typename AP, typename Id>
struct FactoryImpl<AP, Id, NullType>
        : public FactoryImplBase
{
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id ) = 0;
};
template <typename AP, typename Id, typename P1 >
struct FactoryImpl<AP,Id, Seq<P1> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2 >
struct FactoryImpl<AP, Id, Seq<P1, P2> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6 )
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7 )
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm9)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm9,Parm10)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm9,Parm10,
                             Parm11)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm9,Parm10,
                             Parm11,Parm12)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm9,Parm10,
                             Parm11,Parm12,Parm13)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    typedef typename TypeTraits<P14>::ParameterType Parm14;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm8,Parm10,
                             Parm11,Parm12,Parm13,Parm14)
    = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14,typename P15 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >
        : public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    typedef typename TypeTraits<P14>::ParameterType Parm14;
    typedef typename TypeTraits<P15>::ParameterType Parm15;
    virtual ~FactoryImpl() {}
    virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                             Parm6, Parm7, Parm8, Parm9,Parm10,
                             Parm11,Parm12,Parm13,Parm14,Parm15 )
    = 0;
};

#ifndef LOKI_DISABLE_TYPELIST_MACROS

template <typename AP, typename Id, typename P1 >
struct FactoryImpl<AP,Id, LOKI_TYPELIST_1( P1 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_2( P1, P2 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_3( P1, P2, P3 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_4( P1, P2, P3, P4 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_5( P1, P2, P3, P4, P5 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_6( P1, P2, P3, P4, P5, P6 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6 )
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_7( P1, P2, P3, P4, P5, P6, P7 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7 )
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_8( P1, P2, P3, P4, P5, P6, P7, P8 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_9( P1, P2, P3, P4, P5, P6, P7, P8, P9 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_10( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_11( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_12( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11,Parm12)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_13( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11,Parm12,Parm13)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_14( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    typedef typename TypeTraits<P14>::ParameterType Parm14;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm8,Parm10,
                         Parm11,Parm12,Parm13,Parm14)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14,typename P15 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_15( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    typedef typename TypeTraits<P14>::ParameterType Parm14;
    typedef typename TypeTraits<P15>::ParameterType Parm15;
virtual ~FactoryImpl() {}
virtual AP* CreateObject(const Id& id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11,Parm12,Parm13,Parm14,Parm15 )
= 0;
};

#endif //LOKI_DISABLE_TYPELIST_MACROS


////////////////////////////////////////////////////////////////////////////////
///  \class Factory
///
///  \ingroup FactoryGroup
///  Implements a generic object factory.
///
///  Create functions can have up to 15 parameters.
///
///  \par Singleton lifetime when used with Loki::SingletonHolder
///  Because Factory uses internally Functors which inherits from
///  SmallObject you must use the singleton lifetime
///  \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode
///  Alternatively you could suppress for Functor the inheritance
///  from SmallObject by defining the macro:
/// \code LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT \endcode
////////////////////////////////////////////////////////////////////////////////
template
<
class AbstractProduct,
      typename IdentifierType,
      typename CreatorParmTList = NullType,
      template<typename, class> class FactoryErrorPolicy = DefaultFactoryError
      >
class Factory : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
{
    typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl;

    typedef typename Impl::Parm1 Parm1;
    typedef typename Impl::Parm2 Parm2;
    typedef typename Impl::Parm3 Parm3;
    typedef typename Impl::Parm4 Parm4;
    typedef typename Impl::Parm5 Parm5;
    typedef typename Impl::Parm6 Parm6;
    typedef typename Impl::Parm7 Parm7;
    typedef typename Impl::Parm8 Parm8;
    typedef typename Impl::Parm9 Parm9;
    typedef typename Impl::Parm10 Parm10;
    typedef typename Impl::Parm11 Parm11;
    typedef typename Impl::Parm12 Parm12;
    typedef typename Impl::Parm13 Parm13;
    typedef typename Impl::Parm14 Parm14;
    typedef typename Impl::Parm15 Parm15;

    typedef Functor<AbstractProduct*, CreatorParmTList> ProductCreator;

    typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;

    IdToProductMap associations_;

public:

    Factory()
        : associations_()
    {
    }

    ~Factory()
    {
        associations_.erase(associations_.begin(), associations_.end());
    }

    bool Register(const IdentifierType& id, ProductCreator creator)
    {
        return associations_.insert(
                   typename IdToProductMap::value_type(id, creator)).second != 0;
    }

    template <class PtrObj, typename CreaFn>
    bool Register(const IdentifierType& id, const PtrObj& p, CreaFn fn)
    {
        ProductCreator creator( p, fn );
        return associations_.insert(
                   typename IdToProductMap::value_type(id, creator)).second != 0;
    }

    bool Unregister(const IdentifierType& id)
    {
        return associations_.erase(id) != 0;
    }

    std::vector<IdentifierType> RegisteredIds()
    {
        std::vector<IdentifierType> ids;
        for(typename IdToProductMap::iterator it = associations_.begin();
            it != associations_.end(); ++it)
        {
            ids.push_back(it->first);
        }
        return ids;
    }

    AbstractProduct* CreateObject(const IdentifierType& id)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
                                  Parm6 p6)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
                                  Parm6 p6, Parm7 p7 )
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
                                  Parm6 p6, Parm7 p7, Parm8 p8)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
                                  Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9 );
        return this->OnUnknownType(id);
    }
    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
                                  Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9,Parm10 p10)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1  p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5  p5,
                                  Parm6  p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10,
                                  Parm11 p11)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1  p1,  Parm2  p2, Parm3 p3, Parm4 p4, Parm5  p5,
                                  Parm6  p6,  Parm7  p7, Parm8 p8, Parm9 p9, Parm10 p10,
                                  Parm11 p11, Parm12 p12)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1  p1,  Parm2  p2,  Parm3  p3, Parm4 p4, Parm5  p5,
                                  Parm6  p6,  Parm7  p7,  Parm8  p8, Parm9 p9, Parm10 p10,
                                  Parm11 p11, Parm12 p12, Parm13 p13)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4, Parm5  p5,
                                  Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9, Parm10 p10,
                                  Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14 );
        return this->OnUnknownType(id);
    }

    AbstractProduct* CreateObject(const IdentifierType& id,
                                  Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4,  Parm5  p5,
                                  Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9,  Parm10 p10,
                                  Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
            return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15 );
        return this->OnUnknownType(id);
    }

};

#else

template
<
class AbstractProduct,
      typename IdentifierType,
      typename ProductCreator = AbstractProduct* (*)(),
      template<typename, class>
      class FactoryErrorPolicy = DefaultFactoryError
      >
class Factory
    : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
{
public:
    bool Register(const IdentifierType& id, ProductCreator creator)
    {
        return associations_.insert(
                   typename IdToProductMap::value_type(id, creator)).second != 0;
    }

    bool Unregister(const IdentifierType& id)
    {
        return associations_.erase(id) != 0;
    }

    AbstractProduct* CreateObject(const IdentifierType& id)
    {
        typename IdToProductMap::iterator i = associations_.find(id);
        if (i != associations_.end())
        {
            return (i->second)();
        }
        return this->OnUnknownType(id);
    }

private:
    typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
    IdToProductMap associations_;
};

#endif //#define ENABLE_NEW_FACTORY_CODE

/**
 *   \defgroup	CloneFactoryGroup Clone Factory
 *   \ingroup	FactoriesGroup
 *   \brief		Creates a copy from a polymorphic object.
 *
 *   \class		CloneFactory
 *   \ingroup	CloneFactoryGroup
 *   \brief		Creates a copy from a polymorphic object.
 */

template
<
class AbstractProduct,
      class ProductCreator =
      AbstractProduct* (*)(const AbstractProduct*),
      template<typename, class>
      class FactoryErrorPolicy = DefaultFactoryError
      >
class CloneFactory
    : public FactoryErrorPolicy<TypeInfo, AbstractProduct>
{
public:
    bool Register(const TypeInfo& ti, ProductCreator creator)
    {
        return associations_.insert(
                   typename IdToProductMap::value_type(ti, creator)).second != 0;
    }

    bool Unregister(const TypeInfo& id)
    {
        return associations_.erase(id) != 0;
    }

    AbstractProduct* CreateObject(const AbstractProduct* model)
    {
        if (model == NULL)
        {
            return NULL;
        }

        typename IdToProductMap::iterator i =
            associations_.find(typeid(*model));

        if (i != associations_.end())
        {
            return (i->second)(model);
        }
        return this->OnUnknownType(typeid(*model));
    }

private:
    typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
    IdToProductMap associations_;
};

} // namespace Loki


#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif // end file guardian