---

at_factory.h

Go to the documentation of this file.

//
// The Austria library is copyright (c) Gianni Mariani 2004.
// 
// Grant Of License.  Grants to LICENSEE the non-exclusive right to use the Austria
// library subject to the terms of the LGPL.
// 
// A copy of the license is available in this directory or one may be found at this URL:
//      http://www.gnu.org/copyleft/lesser.txt
// 
#ifndef x_at_factory_h_x
#define x_at_factory_h_x 1

#include "at_exports.h"

#include "at_source_locator.h"
#include "at_status_report.h"

#include "at_types.h"
#include "at_lifetime.h"

#include <map>
#include <sstream>

// Austria namespace
namespace at
{

// ======== DKy ====================================================
class AUSTRIA_EXPORT DKy
{
    public:

    inline DKy( const char * i_value )
      : m_value( i_value )
    {
    }

    inline operator const char * () const
    {
        return m_value;
    }

    inline operator AT_String () const
    {
        return AT_String( m_value );
    }

    bool operator==( const DKy i_value ) const;

    bool operator<( const DKy i_value ) const;

    bool operator<=( const DKy i_value ) const;

    bool operator>( const DKy i_value ) const;

    bool operator>=( const DKy i_value ) const;

    private:

    const char        * m_value;    // contains a simple pointer

};

//
// ============================================================================
// ============================================================================
//
// The following classes define templates for passing parameters to
// constructors.
//
// ============================================================================
// ============================================================================
//


// ======== FactoryTraits ==========================================
class AUSTRIA_EXPORT FactoryTraits
{
    public:

    enum FactoryErrorCodes
    {
        FactoryNotFound,

        FactoryCreateException,

        FactoryFailure
    };

    enum FactoryCreateReportingOption
    {

        AllwaysReturn,

        ThrowOnError,

        AssertOnError
    };
        
        
};


// ======== Wrapper_Basic ==========================================
class AUSTRIA_EXPORT Wrapper_Basic
{
    public:

    // ======== ReportError ===========================================
    void ReportError(
        FactoryTraits::FactoryErrorCodes         i_code,
        const AT_String                           & i_msg
    );

    // ======== ReportFactoryNotFound =================================
    void ReportFactoryNotFound();
    
    // ======== ReportCreateException =================================
    void ReportCreateException( const AT_String & i_keystr );


    // ======== ReportFactoryFailed ===================================
    void ReportFactoryFailed( const AT_String & i_keystr );


    // ======== Wrapper_Basic ======================================
    inline Wrapper_Basic(
        StatusReport                                 * io_srep,
        FactoryTraits::FactoryCreateReportingOption    i_create_report_option
    )
      : m_srep( io_srep ),
        m_create_report_option( i_create_report_option )
    {
    }

    StatusReport                                 * m_srep;

    FactoryTraits::FactoryCreateReportingOption    m_create_report_option;

    
};


// ======== KeyToStr ===============================================
template< typename  w_KeyType >
AT_String KeyToStr( const w_KeyType & i_key )
{
    std::ostringstream  l_ostream;

    l_ostream << i_key;
    
    return l_ostream.str();

} // end KeyToStr



// ======== FactoryRegistryEntry ===================================
class AUSTRIA_EXPORT FactoryRegistryEntry
{
    public:

    virtual ~FactoryRegistryEntry()
    {
    }


    // ======== RemoveAndDelete =======================================
    virtual void RemoveAndDelete() = 0;
    
};


// ======== FactoryEntryLocator_Base ===============================
class AUSTRIA_EXPORT FactoryEntryLocator_Base
{
    public:

    FactoryEntryLocator_Base()
      : m_registry_entry( 0 )
    {
    }

    // ======== ~FactoryEntryLocator_Base ===========================
    virtual ~FactoryEntryLocator_Base()
    {   
        FactoryRegistryEntry * l_registry_entry( m_registry_entry );
        
        if ( l_registry_entry != 0 )
        {
            m_registry_entry = 0;

            // this may cause FactoryEntryLocator_Base::RemoveEntry
            // to be called but that's ok since m_registry_entry will
            // be 0 and hence will not do anything.
            l_registry_entry->RemoveAndDelete();
        }
        
    } // end ~FactoryEntryLocator_Base


    // ======== RemoveEntry ===========================================
    void RemoveEntry()
    {

        FactoryRegistryEntry * l_registry_entry( m_registry_entry );

        if ( l_registry_entry != 0 )
        {
            // we can get called recusively.  Setting m_registry_entry
            // breaks the cycle.
            m_registry_entry = 0;

            delete l_registry_entry;
        }

        return;

    } // end RemoveEntry
    
    FactoryRegistryEntry                         * m_registry_entry;

};



// ======== Factory_Base ================================================
template<
    typename    w_KeyType
>
class Factory_Base
  : public SourceLocator_Basic,
    public FactoryEntryLocator_Base
{
    public:

    Factory_Base(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description     
    )
      : SourceLocator_Basic( i_filename, i_lineno ),
        m_description( i_description ),
        m_factory_key( i_key )
    {
    }


    // ======== Size ==================================================
    virtual int Size() = 0;

    
    // ======== GetKey ================================================
    inline const w_KeyType & GetKey() const
    {
        return m_factory_key;
    } // end GetKey

    const char                                      * m_description;

    w_KeyType                                         m_factory_key;

};


// ======== Creator0P ===============================================
template<
    typename    w_InterfaceType,
    typename    w_KeyType
>
class Creator0P
  : public Factory_Base< w_KeyType >
{
    public:


    // ======== Creator0P ===========================================
    inline Creator0P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description     
    )
      : Factory_Base< w_KeyType >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    } // end Creator0P
    

    // ======== Create ================================================
    virtual w_InterfaceType * Create() = 0;

    // ======== Create ================================================
    virtual w_InterfaceType * Create( void * i_location ) = 0;
    

    // ======== Destroy ===============================================
    virtual void Destroy( w_InterfaceType * i_ptr ) = 0;

    
    // ======== CreateWrapper =========================================
    struct CreateWrapper
      : public Wrapper_Basic
    {

        CreateWrapper(
            Creator0P                                    * i_creator,
            StatusReport                                 * o_srep = 0,
            FactoryTraits::FactoryCreateReportingOption    i_option = FactoryTraits::AllwaysReturn
        )
          : Wrapper_Basic( o_srep, i_option ),
            m_creator( i_creator )
        {
        }

        w_InterfaceType * operator() ()
        {
            if ( m_creator == 0 )
            {
                ReportFactoryNotFound();
                return 0;
            }

            w_InterfaceType                         * l_interface;
            
            try
            {
                l_interface = m_creator->Create();
            }
            catch ( ... )
            {
                ReportCreateException( KeyToStr( m_creator->GetKey() ) );

                if ( m_create_report_option == FactoryTraits::ThrowOnError )
                {
                    throw;  // this should re-throw the same exception that was
                            // caught.
                }

                return 0;   // finished.
            }

            if ( l_interface == 0 )
            {
                ReportFactoryFailed( KeyToStr( m_creator->GetKey() ) );
            }

            return l_interface;
        }

        Creator0P                                    * m_creator;

    }; // end CreateWrapper

    //
    // Member variables for Creator0P
    //

};


// ======== CreatorImpl0P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType
>
class CreatorImpl0P
  : public Creator0P< w_InterfaceType, w_KeyType >
{
    public:

    typedef Creator0P< w_InterfaceType, w_KeyType > t_CreatorType;

    CreatorImpl0P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : Creator0P< w_InterfaceType, w_KeyType >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    }
    
    virtual w_InterfaceType * Create()
    {
        return new w_ImplementorType();
    }
    
    virtual int Size()
    {
        return sizeof( w_ImplementorType );
    }

    virtual w_InterfaceType * Create( void * i_location )
    {
        return new ( i_location ) w_ImplementorType;
    }

    virtual void Destroy( w_InterfaceType * i_ptr )
    {
        w_ImplementorType * l_impl = static_cast< w_ImplementorType * >( i_ptr );

        l_impl->~w_ImplementorType();
    }

    
};


// ======== Creator1P ===============================================
template<
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1
>
class Creator1P
  : public Factory_Base< w_KeyType >
{
    public:


    // ======== Creator1P ===========================================
    inline Creator1P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description     
    )
      : Factory_Base< w_KeyType >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    } // end Creator1P
    

    // ======== Create ================================================
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1 ) = 0;

    // ======== Destroy ===============================================
    virtual void Destroy( w_InterfaceType * i_ptr ) = 0;
    
    // ======== Create ================================================
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, void * i_location ) = 0;
    

    // ======== CreateWrapper =========================================
    struct CreateWrapper
      : public Wrapper_Basic
    {

        CreateWrapper(
            Creator1P                                    * i_creator,
            StatusReport                                 * o_srep = 0,
            FactoryTraits::FactoryCreateReportingOption    i_option = FactoryTraits::AllwaysReturn
        )
          : Wrapper_Basic( o_srep, i_option ),
            m_creator( i_creator )
        {
        }

        w_InterfaceType * operator() ( w_arg_1 i_arg_1 )
        {
            if ( m_creator == 0 )
            {
                ReportFactoryNotFound();
                return 0;
            }

            w_InterfaceType                         * l_interface;
            
            try
            {
                l_interface = m_creator->Create( i_arg_1 );
            }
            catch ( ... )
            {
                ReportCreateException( KeyToStr( m_creator->GetKey() ) );

                if ( m_create_report_option == FactoryTraits::ThrowOnError )
                {
                    throw;  // this should re-throw the same exception that was
                            // caught.
                }

                return 0;   // finished.
            }

            if ( l_interface == 0 )
            {
                ReportFactoryFailed( KeyToStr( m_creator->GetKey() ) );
            }

            return l_interface;
        }

        Creator1P                                    * m_creator;

    }; // end CreateWrapper

    //
    // Member variables for Creator1P
    //

};


// ======== CreatorImpl1P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1
>
class CreatorImpl1P
  : public Creator1P< w_InterfaceType, w_KeyType, w_arg_1 >
{
    public:

    typedef Creator1P< w_InterfaceType, w_KeyType, w_arg_1 > t_CreatorType;

    CreatorImpl1P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : Creator1P< w_InterfaceType, w_KeyType, w_arg_1 >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    }
    
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1 )
    {
        return new w_ImplementorType( i_arg_1 );
    }
    
    virtual int Size()
    {
        return sizeof( w_ImplementorType );
    }
    
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, void * i_location )
    {
        return new ( i_location ) w_ImplementorType( i_arg_1 );
    }

    virtual void Destroy( w_InterfaceType * i_ptr )
    {
        w_ImplementorType * l_impl = static_cast< w_ImplementorType * >( i_ptr );

        l_impl->~w_ImplementorType();
    }

};



// ======== Creator2P ===============================================
template<
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1,
    typename    w_arg_2
>
class Creator2P
  : public Factory_Base< w_KeyType >
{
    public:


    // ======== Creator2P ===========================================
    inline Creator2P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description     
    )
      : Factory_Base< w_KeyType >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    } // end Creator2P
    

    // ======== Create ================================================
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2 ) = 0;

    
    // ======== Destroy ===============================================
    virtual void Destroy( w_InterfaceType * i_ptr ) = 0;
    
    
    // ======== Create ================================================
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2, void * i_location ) = 0;


    // ======== CreateWrapper =========================================
    struct CreateWrapper
      : public Wrapper_Basic
    {

        CreateWrapper(
            Creator2P                                    * i_creator,
            StatusReport                                 * o_srep = 0,
            FactoryTraits::FactoryCreateReportingOption    i_option = FactoryTraits::AllwaysReturn
        )
          : Wrapper_Basic( o_srep, i_option ),
            m_creator( i_creator )
        {
        }

        w_InterfaceType * operator() ( w_arg_1 i_arg_1, w_arg_2 i_arg_2 )
        {
            if ( m_creator == 0 )
            {
                ReportFactoryNotFound();
                return 0;
            }

            w_InterfaceType                         * l_interface;
            
            try
            {
                l_interface = m_creator->Create( i_arg_1, i_arg_2 );
            }
            catch ( ... )
            {
                ReportCreateException( KeyToStr( m_creator->GetKey() ) );

                if ( m_create_report_option == FactoryTraits::ThrowOnError )
                {
                    throw;  // this should re-throw the same exception that was
                            // caught.
                }

                return 0;   // finished.
            }

            if ( l_interface == 0 )
            {
                ReportFactoryFailed( KeyToStr( m_creator->GetKey() ) );
            }

            return l_interface;
        }

        Creator2P                                    * m_creator;

    }; // end CreateWrapper

    //
    // Member variables for Creator2P
    //

};


// ======== CreatorImpl2P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1,
    typename    w_arg_2
>
class CreatorImpl2P
  : public Creator2P< w_InterfaceType, w_KeyType, w_arg_1, w_arg_2 >
{
    public:

    typedef Creator2P< w_InterfaceType, w_KeyType, w_arg_1, w_arg_2 > t_CreatorType;

    CreatorImpl2P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : Creator2P< w_InterfaceType, w_KeyType, w_arg_1, w_arg_2 >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    }
    
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2 )
    {
        return new w_ImplementorType( i_arg_1, i_arg_2 );
    }
    
    virtual int Size()
    {
        return sizeof( w_ImplementorType );
    }
    
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2, void * i_location )
    {
        return new ( i_location ) w_ImplementorType( i_arg_1, i_arg_2 );
    }

    virtual void Destroy( w_InterfaceType * i_ptr )
    {
        w_ImplementorType * l_impl = static_cast< w_ImplementorType * >( i_ptr );

        l_impl->~w_ImplementorType();
    }


};

// ======== Creator3P ===============================================
template<
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1,
    typename    w_arg_2,
    typename    w_arg_3
>
class Creator3P
  : public Factory_Base< w_KeyType >
{
    public:


    // ======== Creator3P ===========================================
    inline Creator3P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description     
    )
      : Factory_Base< w_KeyType >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    } // end Creator3P
    

    // ======== Create ================================================
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2, w_arg_3 i_arg_3 ) = 0;

    
    // ======== Destroy ===============================================
    virtual void Destroy( w_InterfaceType * i_ptr ) = 0;
    
    
    // ======== Create ================================================
    virtual w_InterfaceType * Create(
        w_arg_1 i_arg_1, w_arg_2 i_arg_2, w_arg_3 i_arg_3, void * i_location
    ) = 0;


    // ======== CreateWrapper =========================================
    struct CreateWrapper
      : public Wrapper_Basic
    {

        CreateWrapper(
            Creator3P                                    * i_creator,
            StatusReport                                 * o_srep = 0,
            FactoryTraits::FactoryCreateReportingOption    i_option = FactoryTraits::AllwaysReturn
        )
          : Wrapper_Basic( o_srep, i_option ),
            m_creator( i_creator )
        {
        }

        w_InterfaceType * operator() ( w_arg_1 i_arg_1, w_arg_2 i_arg_2, w_arg_3 i_arg_3 )
        {
            if ( m_creator == 0 )
            {
                ReportFactoryNotFound();
                return 0;
            }

            w_InterfaceType                         * l_interface;
            
            try
            {
                l_interface = m_creator->Create( i_arg_1, i_arg_2, i_arg_3 );
            }
            catch ( ... )
            {
                ReportCreateException( KeyToStr( m_creator->GetKey() ) );

                if ( m_create_report_option == FactoryTraits::ThrowOnError )
                {
                    throw;  // this should re-throw the same exception that was
                            // caught.
                }

                return 0;   // finished.
            }

            if ( l_interface == 0 )
            {
                ReportFactoryFailed( KeyToStr( m_creator->GetKey() ) );
            }

            return l_interface;
        }

        Creator3P                                    * m_creator;

    }; // end CreateWrapper

    //
    // Member variables for Creator3P
    //

};


// ======== CreatorImpl3P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1,
    typename    w_arg_2,
    typename    w_arg_3
>
class CreatorImpl3P
  : public Creator3P< w_InterfaceType, w_KeyType, w_arg_1, w_arg_2, w_arg_3 >
{
    public:

    typedef Creator3P< w_InterfaceType, w_KeyType, w_arg_1, w_arg_2, w_arg_3 > t_CreatorType;

    CreatorImpl3P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : Creator3P< w_InterfaceType, w_KeyType, w_arg_1, w_arg_2, w_arg_3 >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
    }
    
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2, w_arg_3 i_arg_3 )
    {
        return new w_ImplementorType( i_arg_1, i_arg_2, i_arg_3 );
    }
    
    virtual int Size()
    {
        return sizeof( w_ImplementorType );
    }
    
    virtual w_InterfaceType * Create( w_arg_1 i_arg_1, w_arg_2 i_arg_2, w_arg_3 i_arg_3, void * i_location )
    {
        return new ( i_location ) w_ImplementorType( i_arg_1, i_arg_2, i_arg_3 );
    }

    virtual void Destroy( w_InterfaceType * i_ptr )
    {
        w_ImplementorType * l_impl = static_cast< w_ImplementorType * >( i_ptr );

        l_impl->~w_ImplementorType();
    }


};


//
// ============================================================================
// ============================================================================
//
// The basic factory class.
//
// ============================================================================
// ============================================================================
//



// ======== FactoryRegisterBase =======================================
class AUSTRIA_EXPORT FactoryRegisterBase
  : public PtrTarget_Basic
{
    public:

    // ======== Key ===================================================
    virtual const DKy * Key() = 0;


    // ======== Version ===============================================
    virtual int Version() = 0;

};


// ======== FactoryRegisterRegistry ===================================
class AUSTRIA_EXPORT FactoryRegisterRegistry
  : public PtrTarget_Basic
{
    public:

    typedef PtrDelegate<FactoryRegisterBase *> ( * t_creator )();

    // ======== FindOrCreate ==========================================
    virtual PtrDelegate<FactoryRegisterBase *> FindOrCreate(
        const DKy               & i_key,
        t_creator                 i_create_meth
    ) = 0;

    // ======== Shutdown ==============================================
    virtual void Shutdown() = 0;

    // ======== Get ===================================================
    static PtrView<FactoryRegisterRegistry *> Get();
};


// ======== FactoryRegister ========================================
template<
    typename    w_InterfaceType,
    typename    w_KeyType = DKy,
    typename    w_CreatorType = Creator0P< w_InterfaceType, w_KeyType >
>
class FactoryRegister
  : public FactoryRegisterBase
{
    private:

    FactoryRegister( const FactoryRegister & );
    
    FactoryRegister()
      : m_register_key( ( typeid( FactoryRegister ) ).name() )
    {
    }

    const DKy                               m_register_key;

    // ======== Create ================================================
    static PtrDelegate<FactoryRegisterBase *> Create()
    {
        return new FactoryRegister();
    }


    // ======== FactoryRegisterVersion ================================
    static int FactoryRegisterVersion()
    {
        return sizeof( FactoryRegister );
    }

    // ======== Key ===================================================
    virtual const DKy * Key()
    {
        return & m_register_key;
    }


    // ======== Version ===============================================
    virtual int Version()
    {
        return FactoryRegisterVersion();
    }

    public:

    struct t_MapEntry
    {
        ~t_MapEntry()
        {
            if ( m_factory != 0 )
            {
                m_factory->RemoveEntry();
            }
        }

        t_MapEntry( const t_MapEntry & i_map_entry )
          : m_factory( i_map_entry.Transfer() )
        {
        }

        t_MapEntry( w_CreatorType * m_factory = 0 )
          : m_factory( m_factory )
        {
        }

        // ======== Transfer ==========================================
        w_CreatorType * Transfer() const
        {
            w_CreatorType * l_factory( m_factory );

            m_factory = 0;
            
            return l_factory;

        } // end Transfer

        mutable w_CreatorType                       * m_factory;

    };

    struct t_EntryCompare
    {
        bool operator()( const w_KeyType * s1, const w_KeyType * s2 ) const
        {
            return (*s1) < (*s2);
        }
    };

    typedef std::map< const w_KeyType *, t_MapEntry, t_EntryCompare >   t_MapType;
    typedef typename t_MapType::iterator                        t_MapIterator;


    // ======== t_FactoryRegistryEntry ================================
    class t_FactoryRegistryEntry
      : public FactoryRegistryEntry
    {
        public:
        
        // described in FactoryRegistryEntry
        //
        virtual void RemoveAndDelete()
        {
            m_pmap->erase( m_location );
            delete this;
        }

        // t_FactoryRegistryEntry constructor
        //
        t_FactoryRegistryEntry(
            t_MapType                                   * i_pmap,
            t_MapIterator                                 i_location
        )
          : m_pmap( i_pmap ),
            m_location( i_location )
        {
        }

        t_MapType                                   * m_pmap;

        t_MapIterator                                 m_location;

    };

    // ======== t_RegistrySingleton ===================================
    class t_RegistrySingleton
    {
        public:

        // ======== Get ===============================================
        FactoryRegister & Get()
        {
            PtrView<FactoryRegister *>       l_register = m_register;
    
            if ( ! l_register )
            {
                PtrView<FactoryRegisterRegistry *> l_frr = FactoryRegisterRegistry::Get();

                Ptr<FactoryRegisterBase *> l_val = l_frr->FindOrCreate(
                    DKy( typeid( FactoryRegister ).name() ),
                    & FactoryRegister::Create
                );

                // nasty down cast - right here !!!
                // Since we know that the pointer is being delegated, we must
                // make sure that the reference count is not increased.  In this
                // case, the reference count of the pointer is not incremented at
                // all.
                m_register = PtrDelegate<FactoryRegister *>(
                    static_cast<FactoryRegister *>( l_val.Transfer() ),
                    false
                );
                
                l_register = m_register;
                
            }

            return * l_register;

        } // end Get

        Ptr<FactoryRegister * >             m_register;

    };
    

    // ======== Get ===================================================
    static FactoryRegister & Get();
    
    // ======== Find ==================================================
    w_CreatorType * Find( const w_KeyType & i_key )
    {
        t_MapIterator   l_location = m_map.find( & i_key );

        if ( l_location == m_map.end() )
        {
            return 0;
        }

        return ( * l_location ).second.m_factory;
    }


    // ======== RegisterInsert ========================================
    void RegisterInsert( w_CreatorType * i_factory )
    {

        //
        // attempt to insert the factory into the map
        //
        
        std::pair<t_MapIterator, bool> l_insert_result =
            m_map.insert( typename t_MapType::value_type( & i_factory->GetKey(), t_MapEntry( i_factory ) ) );

        //
        // If the map already has an entry of this type - return, lack of a
        // m_registry_entry indicates failure.
        //
        if ( ! l_insert_result.second )
        {
            return;
        }

        //
        // create the registry entry - this allows correct clean-up
        i_factory->m_registry_entry = new t_FactoryRegistryEntry(
            & m_map,
            l_insert_result.first
        );
    }


    // ======== Create ==============================================
    static typename w_CreatorType::CreateWrapper Create(
        const w_KeyType                                 & i_key,
        StatusReport                                 * o_srep = 0,
        FactoryTraits::FactoryCreateReportingOption    i_option = FactoryTraits::AllwaysReturn
    )
    {
        return typename w_CreatorType::CreateWrapper(
            Get().Find( i_key ),
            o_srep,
            i_option
        );
    } // end Initiate

    
    t_MapType                                         m_map;

};

// =====================================================================
//
//

#ifndef AT_Factory_Home
#define AT_Factory_Home 1
#endif

#if AT_Factory_Home

// ======== FactoryRegister<w_InterfaceType, w_KeyType, w_CreatorType>::Get() ==========
template<
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_CreatorType
>
FactoryRegister<w_InterfaceType, w_KeyType, w_CreatorType>
    & FactoryRegister<w_InterfaceType, w_KeyType, w_CreatorType>::Get()
{
    static t_RegistrySingleton        s_reg;

    return s_reg.Get();

} // end FactoryRegister<w_InterfaceType, w_KeyType, w_CreatorType>::Get()

#endif

//
//
// =====================================================================

// ======== FactoryImpl0P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType = DKy
>
class FactoryImpl0P
  : public CreatorImpl0P< w_ImplementorType, w_InterfaceType, w_KeyType >
{
    public:

    typedef typename FactoryImpl0P::t_CreatorType        t_RegistryCreatorType;

    FactoryImpl0P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : CreatorImpl0P< w_ImplementorType, w_InterfaceType, w_KeyType >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
        //
        // Insert this factory into the factory register.
        //
        FactoryRegister< w_InterfaceType, w_KeyType, t_RegistryCreatorType >::Get().RegisterInsert(
            this
        );
    }
    
};

// ======== FactoryImpl1P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1
>
class FactoryImpl1P
  : public CreatorImpl1P< w_ImplementorType, w_InterfaceType, w_KeyType, w_arg_1 >
{
    public:

    typedef typename FactoryImpl1P::t_CreatorType        t_RegistryCreatorType;

    FactoryImpl1P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : CreatorImpl1P< w_ImplementorType, w_InterfaceType, w_KeyType, w_arg_1 >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
        //
        // Insert this factory into the factory register.
        //
        FactoryRegister< w_InterfaceType, w_KeyType, t_RegistryCreatorType >::Get().RegisterInsert(
            this
        );
    }
    
};

// ======== FactoryImpl2P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1,
    typename    w_arg_2
>
class FactoryImpl2P
  : public CreatorImpl2P< w_ImplementorType, w_InterfaceType, w_KeyType, w_arg_1, w_arg_2 >
{
    public:

    typedef typename FactoryImpl2P::t_CreatorType        t_RegistryCreatorType;

    FactoryImpl2P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : CreatorImpl2P< w_ImplementorType, w_InterfaceType, w_KeyType, w_arg_1, w_arg_2 >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
        //
        // Insert this factory into the factory register.
        //
        FactoryRegister< w_InterfaceType, w_KeyType, t_RegistryCreatorType >::Get().RegisterInsert(
            this
        );
    }

};

// ======== FactoryImpl3P ===========================================
template<
    typename    w_ImplementorType,
    typename    w_InterfaceType,
    typename    w_KeyType,
    typename    w_arg_1,
    typename    w_arg_2,
    typename    w_arg_3
>
class FactoryImpl3P
  : public CreatorImpl3P< w_ImplementorType, w_InterfaceType, w_KeyType, w_arg_1, w_arg_2, w_arg_3 >
{
    public:

    typedef typename FactoryImpl3P::t_CreatorType        t_RegistryCreatorType;

    FactoryImpl3P(
        w_KeyType                                     i_key,
        const char                                  * i_filename,
        int                                           i_lineno,
        const char                                  * i_description
    )
      : CreatorImpl3P< w_ImplementorType, w_InterfaceType, w_KeyType, w_arg_1, w_arg_2, w_arg_3 >(
            i_key,
            i_filename,
            i_lineno,
            i_description
        )
    {
        //
        // Insert this factory into the factory register.
        //
        FactoryRegister< w_InterfaceType, w_KeyType, t_RegistryCreatorType >::Get().RegisterInsert(
            this
        );
    }

};

// ======== AT_FactorySymbolRef?P =====================================
#define AT_FactorySymbolRef(x_Name,x_NumParam) x_g_f ## x_Name ## _ ## x_NumParam ## P_ref

// ======== AT_MakeFactory?P ==========================================
#define AT_MakeFactory0P(x_Key, x_Impl, x_Interface, x_KeyType)             \
    FactoryImpl0P<x_Impl, x_Interface, x_KeyType>                        \
        x_g_f ## x_Impl ## _0P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key ); \
    extern "C" { void * AT_FactorySymbolRef(x_Impl,0) = static_cast<void *>( & x_g_f ## x_Impl ## _0P ); };

#define AT_MakeFactory1P(x_Key, x_Impl, x_Interface, x_KeyType, x_arg1)     \
    FactoryImpl1P<x_Impl, x_Interface, x_KeyType, x_arg1>                \
        x_g_f ## x_Impl ## _1P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key ); \
    extern "C" { void * AT_FactorySymbolRef(x_Impl,1) = static_cast<void *>( & x_g_f ## x_Impl ## _1P ); };

#define AT_MakeFactory2P(x_Key, x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2)     \
    FactoryImpl2P<x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2>                \
        x_g_f ## x_Impl ## _2P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key ); \
    extern "C" { void * AT_FactorySymbolRef(x_Impl,2) = static_cast<void *>( & x_g_f ## x_Impl ## _2P ); };

#define AT_MakeFactory3P(x_Key, x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2, x_arg3)     \
    FactoryImpl3P<x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2, x_arg3>                \
        x_g_f ## x_Impl ## _3P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key ); \
    extern "C" { void * AT_FactorySymbolRef(x_Impl,3) = static_cast<void *>( & x_g_f ## x_Impl ## _3P ); };


// ======== AT_MakeNamedFactory?P =============================
#define AT_MakeNamedFactory0P(x_Name, x_Key, x_Impl, x_Interface, x_KeyType)                \
    FactoryImpl0P<x_Impl, x_Interface, x_KeyType>                        \
        x_g_f ## x_Name ## _0P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key " " # x_Name ); \
    extern "C" { void * AT_FactorySymbolRef(x_Name,0) = static_cast<void *>( & x_g_f ## x_Name ## _0P ); };

#define AT_MakeNamedFactory1P(x_Name, x_Key, x_Impl, x_Interface, x_KeyType, x_arg1)        \
    FactoryImpl1P<x_Impl, x_Interface, x_KeyType, x_arg1>                \
        x_g_f ## x_Name ## _1P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key " " # x_Name ); \
    extern "C" { void * AT_FactorySymbolRef(x_Name,1) = static_cast<void *>( & x_g_f ## x_Name ## _1P ); };

#define AT_MakeNamedFactory2P(x_Name, x_Key, x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2) \
    FactoryImpl2P<x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2>                \
        x_g_f ## x_Name ## _2P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key " " # x_Name ); \
    extern "C" { void * AT_FactorySymbolRef(x_Name,2) = static_cast<void *>( & x_g_f ## x_Name ## _2P ); };

#define AT_MakeNamedFactory3P(x_Name, x_Key, x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2, x_arg3) \
    FactoryImpl3P<x_Impl, x_Interface, x_KeyType, x_arg1, x_arg2, x_arg3>                \
        x_g_f ## x_Name ## _3P( x_Key, __FILE__, __LINE__, # x_Interface " " # x_Impl " " # x_Key " " # x_Name ); \
    extern "C" { void * AT_FactorySymbolRef(x_Name,3) = static_cast<void *>( & x_g_f ## x_Name ## _3P ); };


// ======== AT_MakeCUnitLink ==================================
#define AT_MakeCUnitLink_Name(name)     x_AT_CUnit_##name
#define AT_MakeCUnitLink(name)          int AT_MakeCUnitLink_Name(name)[1];
#define AT_MakeCUnitLinkExtern(name)    extern int AT_MakeCUnitLink_Name(name)[];


// ======== AT_HardLinkExtern =========================================
#define AT_HardLinkExtern(x_Name,x_NumParam)    \
    extern "C" { extern void * AT_FactorySymbolRef(x_Name,x_NumParam); };


// ======== AT_HardLinkArrayElement ===================================
#define AT_HardLinkArrayElement(x_Name,x_NumParam)  \
    & AT_FactorySymbolRef(x_Name,x_NumParam),

 // end of GenericFactories ( Doxygen group )

}; // namespace
#endif // x_at_factory_h_x

Generated for Austria by and MakeXS at Sun Oct 24 17:35:34 PDT 2004