factory.h

/********************************************************************************
 *  FARSA - Total99                                                             *
 *  Copyright (C) 2008-2011 Tomassino Ferrauto <t_ferrauto@yahoo.it>            *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program 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 General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef FACTORY_H
#define FACTORY_H

#include "configurationconfig.h"
#include "parametersettable.h"
#include <QString>
#include <QStringList>
#include <QMap>
#include <QList>
#include <QVector>
#include <typeinfo>
#include <memory>

namespace farsa {

class RealFactory;
class ParameterSettableCreator;
class ConfigurationWidget;

class FARSA_CONF_TEMPLATE ConfigurationWidgetCreator
{
public:
    virtual ~ConfigurationWidgetCreator()
    {
    }

    virtual ConfigurationWidget* create(ConfigurationParameters& params, QString prefix, QWidget* parent, Qt::WindowFlags f) const = 0;
};

template <class T>
class FARSA_CONF_TEMPLATE ConfigurationWidgetCreatorT : public ConfigurationWidgetCreator
{
public:
    virtual ~ConfigurationWidgetCreatorT()
    {
    }

    virtual ConfigurationWidget* create(ConfigurationParameters& params, QString prefix, QWidget* parent, Qt::WindowFlags f) const;
};

class FARSA_CONF_API Factory {
public:
    static Factory& getInstance();

    static ConfigurationParameters& getTypeDescriptions();

    ~Factory();

    template <class NewClass>
    void registerClass(QString className, QString parentClassName);

    QStringList getAllSubclasses(QString className, int levelToStop = -1, bool noAbstractClasses = false);

    bool isAbstract(QString className);

    template <class EditorType>
    void registerEditorForType(QString type);

    ConfigurationWidget* getEditorForType(ConfigurationParameters& params, QString prefix, QWidget* parent = NULL, Qt::WindowFlags f = 0);

private:
    void cleanupMapsForReRegistration(QString className);

    template <class T, class U>
    class Conversion
    {
        // Type1 and Type2 have surely two different sizes
        typedef char Type1;
        class Type2
        {
            char dummy[2];
        };
        static Type1 Test(U);
        static Type2 Test(...);
        static T MakeT();
    public:
        enum { exists = sizeof(Test(MakeT())) == sizeof(Type1) };
    };

    template<bool canBeCreated, class H>
    class RegisterClassHelper {
    public:
        RegisterClassHelper(Factory* factory, QString className, QString parentClassName);
    };

    Factory();

    Factory(const Factory &other);

    Factory& operator=(const Factory &other);

    QMap<QString, ParameterSettableCreator*> m_classMap;

    QMap<QString, QString> m_parentsMap;
    
    QMap<QString, QStringList> m_childrenMap;

    QMap<QString, ConfigurationWidgetCreator*> m_editorsMap;

    friend class RealFactory;
};

} // end namespace farsa

// Implementation of template functions
#include "configurationparameters.h"
#include "realfactory.h"

namespace farsa {

template <class T>
ConfigurationWidget* ConfigurationWidgetCreatorT<T>::create(ConfigurationParameters& params, QString prefix, QWidget* parent, Qt::WindowFlags f) const
{
    // Addind a group separator at the end of the prefix
    const QString terminatedPrefix = prefix + ConfigurationParameters::GroupSeparator();

    // Creating the new editor
    std::auto_ptr<T> t(new T(params, terminatedPrefix, parent, f));

    return t.release();
}

// This namespace contains helper code. We put it in an inner namespace to avoid polluting the farsa namespace
namespace __Factory_internal {
    // this local template check if a class is Abstract
    // it's is needed because for register a complete hierarchy it's necessary
    // also to check if a class is abstract so it can be possible to register also
    // abstract class
    template<class T>
    struct checkClass {
        // Inspired by boost/type_traits/is_abstract.hpp
        // Deduction fails if T is void, function type,
        // reference type (14.8.2/2)or an abstract class type
        // according to review status issue #337
        template<class U>
        static char check_sig(U (*)[1]);
        template<class U>
        static short check_sig(...);
        static const bool isAbstract = (sizeof(check_sig<T>(0))!=sizeof(char));
        // correspond to !isAbstract
        static const bool canBeCreated = (sizeof(check_sig<T>(0))==sizeof(char));
    };
}

template <class H>
class Factory::RegisterClassHelper<true, H> {
public:
    RegisterClassHelper(Factory* factory, QString className, QString parentClassName) {
        factory->cleanupMapsForReRegistration(className);
        factory->m_classMap[className] = new ParameterSettableCreatorT<H, Conversion<H *, ParameterSettableInConstructor *>::exists>();
        factory->m_parentsMap[className] = parentClassName;
        factory->m_childrenMap[parentClassName].append( className );
        H::describe( className );
    };
};

template <class H>
class Factory::RegisterClassHelper<false, H> {
public:
    RegisterClassHelper(Factory* factory, QString className, QString parentClassName) {
        factory->cleanupMapsForReRegistration(className);
        factory->m_parentsMap[className] = parentClassName;
        factory->m_childrenMap[parentClassName].append( className );
    };
};

template <class NewClass>
void Factory::registerClass(QString className, QString parentClassName)
{
    RegisterClassHelper<__Factory_internal::checkClass<NewClass>::canBeCreated, NewClass> registerHelper(this, className, parentClassName );
}

template <class EditorType>
void Factory::registerEditorForType(QString type)
{
    // Checking type if in typeDescriptions
    //if (!getTypeDescriptions().isGroup(type)) {
    //  throw ConfigurationWidgetForUnknownTypeException(type.toAscii().data());
    //}

    // Removing the old creator, if it existed
    if (m_editorsMap.contains(type)) {
        delete m_editorsMap[type];

        m_editorsMap[type] = NULL;
    }

    // Creating the new creator
    m_editorsMap[type] = new ConfigurationWidgetCreatorT<EditorType>();
}

template <class EditorType>
void ParameterSettable::setGraphicalEditor( QString type )
{
    Factory::getInstance().registerEditorForType<EditorType>(type);
}

} // end namespace farsa

#endif