////////////////////////////////////////////////////////////////////////////////
// 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$


#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;
        }

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

        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;
        }

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

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

            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