Source: kgenericfactory.h

/* This file is part of the KDE project
 * Copyright (C) 2001 Simon Hausmann 
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
#ifndef __kgenericfactory_h__
#define __kgenericfactory_h__

#include 
#include 
#include 
#include 
#include 
#include 

/* @internal */
template 
class KGenericFactoryBase 
{
public:
    KGenericFactoryBase( const char *instanceName )
        : m_instanceName( instanceName ) 
    {
        s_self = this;
    }
    virtual ~KGenericFactoryBase()
    {
        if ( s_instance )
            KGlobal::locale()->removeCatalogue( s_instance->instanceName() );
        delete s_instance;
        s_instance = 0;
        s_self = 0;
    }

    static KInstance *instance();

protected:
    virtual KInstance *createInstance()
    {
        if ( !m_instanceName )
            return 0; // ### assert
        return new KInstance( m_instanceName );
    }

    virtual void setupTranslations( void )
    {
        if ( instance() )
            KGlobal::locale()->insertCatalogue( instance()->instanceName() );
    }

    void initializeMessageCatalogue()
    {
        static bool catalogueInitialized = false;
        if ( !catalogueInitialized )
        {
            catalogueInitialized = true;
            setupTranslations();
        }
    }

private:
    QCString m_instanceName;

    static KInstance *s_instance;
    static KGenericFactoryBase *s_self;
};

/* @internal */
template 
KInstance *KGenericFactoryBase::s_instance = 0;

/* @internal */
template 
KGenericFactoryBase *KGenericFactoryBase::s_self = 0;

/* @internal */
template 
KInstance *KGenericFactoryBase::instance()
{
    if ( !s_instance && s_self )
        s_instance = s_self->createInstance();
    return s_instance;
}

/**
 * This template provides a generic implementation of a @ref KLibFactory ,
 * for use with shared library components. It implements the pure virtual
 * createObject method of KLibFactory and instantiates objects of the
 * specified class (template argument) when the class name argument of
 * createObject matches a class name in the given hierarchy.
 *
 * Note that the class specified as template argument needs to provide
 * a certain constructor:
 * 

 *     
If the class is derived from QObject then it needs to have
 *         a constructor like:
 *         MyClass( QObject *parent, const char *name,
 *                        const QStringList &args );
 *     
If the class is derived from QWidget then it needs to have
 *         a constructor like:
 *         MyWidget( QWidget *parent, const char *name,
 *                         const QStringList &args);
 *     
If the class is derived from KParts::Part then it needs to have
 *         a constructor like:
 *         MyPart( QWidget *parentWidget, const char *widgetName,
 *                       QObject *parent, const char *name,
 *                       const QStringList &args );
 * 
 * The args QStringList passed to the constructor is the args string list
 * that the caller passed to KLibFactory's create method.
 *
 * In addition upon instantiation this template provides a central 
 * @ref KInstance object for your component, accessible through the
 * static @ref instance() method. The instanceName argument of the
 * KGenericFactory constructor is passed to the KInstance object.
 *
 * The creation of the KInstance object can be customized by inheriting
 * from this template class and re-implementing the virtual createInstance
 * method. For example it could look like this:
 * 
 *     KInstance *MyFactory::createInstance()
 *     {
 *         return new KInstance( myAboutData );
 *     }
 * 
 *
 * Example of usage of the whole template:
 * 
 *     class MyPlugin : public KParts::Plugin
 *     {
 *         Q_OBJECT
 *     public:
 *         MyPlugin( QObject *parent, const char *name,
 *                   const QStringList &args );
 *         ...
 *     };
 *
 *     K_EXPORT_COMPONENT_FACTORY( libmyplugin, KGenericFactory<MyPlugin> );
 * 
 */
template 
class KGenericFactory : public KLibFactory, public KGenericFactoryBase
{
public:
    KGenericFactory( const char *instanceName = 0 )
        : KGenericFactoryBase( instanceName ) 
    {}

protected:
    virtual QObject *createObject( QObject *parent, const char *name,
                                  const char *className, const QStringList &args )
    {   
        initializeMessageCatalogue();
        return KDEPrivate::ConcreteFactory
            ::create( 0, 0, parent, name, className, args );
    }
};

/**
 * This template provides a generic implementation of a @ref KLibFactory ,
 * for use with shared library components. It implements the pure virtual
 * createObject method of KLibFactory and instantiates objects of the
 * specified classes in the given typelist template argument when the class 
 * name argument of createObject matches a class names in the given hierarchy
 * of classes.
 * 
 * Note that each class in the specified in the typelist template argument 
 * needs to provide a certain constructor:
 * 

 *     
If the class is derived from QObject then it needs to have
 *         a constructor like:
 *         MyClass( QObject *parent, const char *name,
 *                        const QStringList &args );
 *     
If the class is derived from QWidget then it needs to have
 *         a constructor like:
 *         MyWidget( QWidget *parent, const char *name,
 *                         const QStringList &args);
 *     
If the class is derived from KParts::Part then it needs to have
 *         a constructor like:
 *         MyPart( QWidget *parentWidget, const char *widgetName,
 *                       QObject *parent, const char *name,
 *                       const QStringList &args );
 * 
 * The args QStringList passed to the constructor is the args string list
 * that the caller passed to KLibFactory's create method.
 *
 * In addition upon instantiation this template provides a central 
 * @ref KInstance object for your component, accessible through the
 * static @ref instance() method. The instanceName argument of the
 * KGenericFactory constructor is passed to the KInstance object.
 *
 * The creation of the KInstance object can be customized by inheriting
 * from this template class and re-implementing the virtual createInstance
 * method. For example it could look like this:
 * 
 *     KInstance *MyFactory::createInstance()
 *     {
 *         return new KInstance( myAboutData );
 *     }
 * 
 *
 * Example of usage of the whole template:
 * 
 *     class MyPlugin : public KParts::Plugin
 *     {
 *         Q_OBJECT
 *     public:
 *         MyPlugin( QObject *parent, const char *name,
 *                   const QStringList &args );
 *         ...
 *     };
 *
 *     class MyDialogComponent : public KDialogBase
 *     {
 *         Q_OBJECT
 *     public:
 *         MyDialogComponent( QWidget *parentWidget, const char *name,
 *                            const QStringList &args );
 *         ...
 *     };
 *
 *     typedef K_TYPELIST_2( MyPlugin, MyDialogComponent ) Products;
 *     K_EXPORT_COMPONENT_FACTORY( libmyplugin, KGenericFactory<Products> );
 * 
 */
template 
class KGenericFactory< KTypeList, QObject > 
    : public KLibFactory,
      public KGenericFactoryBase< KTypeList >
{
public:
    KGenericFactory( const char *instanceName  = 0 )
        : KGenericFactoryBase< KTypeList >( instanceName )
    {}

protected:
    virtual QObject *createObject( QObject *parent, const char *name,
                                   const char *className, const QStringList &args )
    {
        initializeMessageCatalogue();
        return KDEPrivate::MultiFactory< KTypeList< Product, ProductListTail > >
            ::create( 0, 0, parent, name, className, args );
    }
};

/**
 * This template provides a generic implementation of a @ref KLibFactory ,
 * for use with shared library components. It implements the pure virtual
 * createObject method of KLibFactory and instantiates objects of the
 * specified classes in the given typelist template argument when the class 
 * name argument of createObject matches a class names in the given hierarchy
 * of classes.
 * 
 * Note that each class in the specified in the typelist template argument 
 * needs to provide a certain constructor:
 * 

 *     
If the class is derived from QObject then it needs to have
 *         a constructor like:
 *         MyClass( QObject *parent, const char *name,
 *                        const QStringList &args );
 *     
If the class is derived from QWidget then it needs to have
 *         a constructor like:
 *         MyWidget( QWidget *parent, const char *name,
 *                         const QStringList &args);
 *     
If the class is derived from KParts::Part then it needs to have
 *         a constructor like:
 *         MyPart( QWidget *parentWidget, const char *widgetName,
 *                       QObject *parent, const char *name,
 *                       const QStringList &args );
 * 
 * The args QStringList passed to the constructor is the args string list
 * that the caller passed to KLibFactory's create method.
 *
 * In addition upon instantiation this template provides a central 
 * @ref KInstance object for your component, accessible through the
 * static @ref instance() method. The instanceName argument of the
 * KGenericFactory constructor is passed to the KInstance object.
 *
 * The creation of the KInstance object can be customized by inheriting
 * from this template class and re-implementing the virtual createInstance
 * method. For example it could look like this:
 * 
 *     KInstance *MyFactory::createInstance()
 *     {
 *         return new KInstance( myAboutData );
 *     }
 * 
 *
 * Example of usage of the whole template:
 * 
 *     class MyPlugin : public KParts::Plugin
 *     {
 *         Q_OBJECT
 *     public:
 *         MyPlugin( QObject *parent, const char *name,
 *                   const QStringList &args );
 *         ...
 *     };
 *
 *     class MyDialogComponent : public KDialogBase
 *     {
 *         Q_OBJECT
 *     public:
 *         MyDialogComponent( QWidget *parentWidget, const char *name,
 *                            const QStringList &args );
 *         ...
 *     };
 *
 *     typedef K_TYPELIST_2( MyPlugin, MyDialogComponent ) Products;
 *     K_EXPORT_COMPONENT_FACTORY( libmyplugin, KGenericFactory<Products> );
 * 
 */
template 
class KGenericFactory< KTypeList,
                       KTypeList > 
    : public KLibFactory,
      public KGenericFactoryBase< KTypeList >
{
public:
    KGenericFactory( const char *instanceName  = 0 )
        : KGenericFactoryBase< KTypeList >( instanceName )
    {}

protected:
    virtual QObject *createObject( QObject *parent, const char *name,
                                   const char *className, const QStringList &args )
    {
        initializeMessageCatalogue();
        return KDEPrivate::MultiFactory< KTypeList< Product, ProductListTail >,
                                         KTypeList< ParentType, ParentTypeListTail > >
                                       ::create( 0, 0, parent, name,
                                                 className, args );
    }
};


/*
 * vim: et sw=4
 */

#endif