realfactory.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 REAL_FACTORY_H
#define REAL_FACTORY_H

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

namespace farsa {

class ConfigurationParameters;

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

    virtual ParameterSettable* create(ConfigurationParameters& settings, QString prefix, bool configure) const = 0;

    virtual bool canDeferConfiguration() const = 0;
};

template <class T, bool ConfigureInConstructor>
class FARSA_CONF_TEMPLATE ParameterSettableCreatorT : public ParameterSettableCreator
{
public:
    virtual ~ParameterSettableCreatorT()
    {
    }

    virtual ParameterSettableInConstructor* create(ConfigurationParameters& settings, QString prefix, bool configure) const;

    virtual bool canDeferConfiguration() const
    {
        return false;
    }
};

template <class T>
class FARSA_CONF_TEMPLATE ParameterSettableCreatorT<T, false> : public ParameterSettableCreator
{
public:
    virtual ~ParameterSettableCreatorT()
    {
    }

    virtual ParameterSettableWithConfigureFunction* create(ConfigurationParameters& settings, QString prefix, bool configure) const;

    virtual bool canDeferConfiguration() const
    {
        return true;
    }
};

class FARSA_CONF_API RealFactory {
public:
    RealFactory(ConfigurationParameters& configurationParameters);

    ~RealFactory();

    void addObserver(FactoryObserver* observer);

    void addObservers(const QSet<FactoryObserver*>& observers);

    const QSet<FactoryObserver*>& getObservers() const;

    void clearObservers();

    template <class TypeToCreate>
    TypeToCreate* create(const QString& className, QString prefix, bool configure = true, bool* actuallyConfigured = NULL);

    template <class TypeToCreate>
    TypeToCreate* createFromParameter(QString prefix, bool configure = true, bool* actuallyConfigured = NULL);

    template <class TypeToCreate>
    QList<TypeToCreate *> createListFromParameter(QString prefix, QString basename);

    template <class TypeToCreate>
    QVector<TypeToCreate *> createVectorFromParameter(QString prefix, QString basename);

    void objectConfigured(ParameterSettable *object);

    bool outsideCallsToCreate() const;

    void callPostConfigureInitializationForConfiguredObjects();

private:
    ConfigurationParameters& m_configurationParameters;

    QSet<FactoryObserver*> m_observers;

    unsigned int m_createRecursionLevel;

    QList<ParameterSettable*> m_objectsConfiguredNotInitialized;

private:
    static bool orderByNumberAfterColon(const QString& s1, const QString& s2);

private:
    RealFactory(const RealFactory &other);

    RealFactory& operator=(const RealFactory &other);
};

} // end namespace farsa

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

namespace farsa {

template <class T, bool ConfigureInConstructor>
ParameterSettableInConstructor* ParameterSettableCreatorT<T, ConfigureInConstructor>::create(ConfigurationParameters& settings, QString prefix, bool /*configure*/) const
{
    QString terminatedPrefix = prefix + ConfigurationParameters::GroupSeparator();

    // Telling the ConfigurationParameters object that the object for the group in terminatedPrefix is about
    // to be created and configured
    if (!settings.setObjectFromGroupStatusToCreatingAndConfiguring(terminatedPrefix)) {
        throw PrefixNotGroupException(prefix.toLatin1().data());
    }

    std::auto_ptr<T> t(new T(settings, terminatedPrefix));

    // Telling the ConfigurationParameters object that the object for the group in terminatedPrefix has been
    // created and configured
    if (!settings.setObjectFromGroupStatusToCreatedAndConfigured(terminatedPrefix, t.get())) {
        throw PrefixNotGroupException(prefix.toLatin1().data());
    }

    return t.release();
}

template <class T>
ParameterSettableWithConfigureFunction* ParameterSettableCreatorT<T, false>::create(ConfigurationParameters& settings, QString prefix, bool configure) const
{
    QString terminatedPrefix = prefix + ConfigurationParameters::GroupSeparator();

    // Telling the ConfigurationParameters object that the object for the group in terminatedPrefix is about
    // to be created
    if (!settings.setObjectFromGroupStatusToCreating(terminatedPrefix)) {
        throw PrefixNotGroupException(prefix.toLatin1().data());
    }

    std::auto_ptr<T> t(new T());

    // Telling the ConfigurationParameters object that the object for the group in terminatedPrefix has been
    // created but not yet configured
    if (!settings.setObjectFromGroupStatusToCreatedNotConfigured(terminatedPrefix, t.get())) {
        throw PrefixNotGroupException(prefix.toLatin1().data());
    }

    if (configure) {
        // Telling the ConfigurationParameters object that the object for the group in terminatedPrefix is about
        // to be configured
        if (!settings.setObjectFromGroupStatusToConfiguring(terminatedPrefix)) {
            throw PrefixNotGroupException(prefix.toLatin1().data());
        }

        t->configure(settings, terminatedPrefix);

        // Telling the ConfigurationParameters object that the object for the group in terminatedPrefix has been
        // created and configured
        if (!settings.setObjectFromGroupStatusToCreatedAndConfigured(terminatedPrefix)) {
            throw PrefixNotGroupException(prefix.toLatin1().data());
        }
    }

    return t.release();
}

template <class TypeToCreate>
TypeToCreate* RealFactory::create(const QString& className, QString prefix, bool configure, bool* actuallyConfigured)
{
    // This is a simple class to implement RAII for the m_createRecursionLevel variable, so that in case
    // an exception is thrown, its value is correctly restored to the previous one
    class RecursionLevelRAII
    {
    public:
        RecursionLevelRAII(unsigned int& createRecursionLevel, QList<ParameterSettable*>& objectsConfiguredNotInitialized) :
            m_createRecursionLevel(createRecursionLevel)
        {
            if (m_createRecursionLevel == 0) {
                // As this is the first call to create for the current m_settings, we remove the list of objects, if
                // present (this could be here because the previous set of calls ended with an exception)
                objectsConfiguredNotInitialized.clear();
            }
            m_createRecursionLevel++;
        }

        ~RecursionLevelRAII() throw()
        {
            m_createRecursionLevel--;
        }

    private:
        unsigned int& m_createRecursionLevel;

        // We put implementations to avoid warning under windows. Anyway, these are private, so
        // nobody can call them.
        RecursionLevelRAII(const RecursionLevelRAII& other) : m_createRecursionLevel(other.m_createRecursionLevel) {}
        RecursionLevelRAII& operator=(const RecursionLevelRAII& /*other*/) { return *this; }
    };

    // Incrementing the recursion level for this function
    RecursionLevelRAII recursionLevelRAII(m_createRecursionLevel, m_objectsConfiguredNotInitialized);

    // Checking that the class map contains the class name
    if (!Factory::getInstance().m_classMap.contains(className)) {
        // checking if its abstract
        if ( Factory::getInstance().m_parentsMap.contains(className) ) {
            // its an abstract class
            throw ClassNameIsAbstractException(className.toLatin1().data());
        } else {
            throw ClassNameNotRegisteredException(className.toLatin1().data());
        }
    }

    // First of all checking if it is possible to create and not configure the object
    if (!Factory::getInstance().m_classMap[className]->canDeferConfiguration()) {
        configure = true;
    }
    if (actuallyConfigured != NULL) {
        (*actuallyConfigured) = configure;
    }

    // Using auto_ptr to be sure to delete the object if something goes wrong (RAII)
    std::auto_ptr<ParameterSettable> newObj(Factory::getInstance().m_classMap[className]->create(m_configurationParameters, prefix, configure));
    TypeToCreate* obj = dynamic_cast<TypeToCreate*>(newObj.get());

    if (obj == NULL) {
        throw CannotConvertToTypeException(className.toLatin1().data(), typeid(TypeToCreate));
    }

    // set the typeName to the newly created object
    obj->setTypeName( className );

    // If the object has been configured, adding it to the list of objects to be initialized
    if (configure) {
        m_objectsConfiguredNotInitialized.append(obj);
    }

    // If we are outside any call to ConfigurationParameters::getObjectFromGroup() and this is the most external
    // call to create (m_createRecursionLevel has been incremented from 0 to 1 by the constructor of RecursionLevelRAII),
    // here we initialize all objects that have been configured. If the most external call to this function have been
    // performed inside a call to ConfigurationParameters::getObjectFromGroup(), that function will do the job
    // NOTE: this check should be useless now that create is protected and can only be called by ConfigurationParameters:
    //       calling postConfigureInitialization is always done inside ConfigurationParameters::getObjectFromGroup().
    //       Leaving it here, however, creates no harm (so, just to be sure, we don't touch it)
    if (m_configurationParameters.outsideCallsToGetObjectFromGroup() && (m_createRecursionLevel == 1)) {
        callPostConfigureInitializationForConfiguredObjects();
    }

    // notify observers
    foreach(FactoryObserver* obs, m_observers) {
        obs->onObjectCreation(&m_configurationParameters, obj, prefix, configure);
    }

    // Releasing the auto_ptr to prevent object deallocation
    newObj.release();

    return obj;
}

template <class TypeToCreate>
TypeToCreate* RealFactory::createFromParameter(QString prefix, bool configure, bool* actuallyConfigured)
{
    QString type = m_configurationParameters.getValue(prefix + ConfigurationParameters::GroupSeparator() + QString("type"), false);

    if (!type.isNull()) {
        return create<TypeToCreate>(type, prefix, configure, actuallyConfigured);
    }

    throw CannotFindTypeParameterException(prefix.toLatin1().data());

    return NULL;
}

template <class TypeToCreate>
QList<TypeToCreate *> RealFactory::createListFromParameter(QString prefix, QString basename)
{
    // The list of objects to return
    QList<TypeToCreate *> objects;
    // Getting the list of groups under prefix
    QStringList objectsGroups = m_configurationParameters.getGroupsWithPrefixList(prefix, basename);

    // Now creating all groups
    for (QStringList::iterator it = objectsGroups.begin(); it != objectsGroups.end(); it++) {
        objects.push_back(createFromParameter<TypeToCreate>(prefix + ConfigurationParameters::GroupSeparator() + *it));
    }

    return objects;
}

template <class TypeToCreate>
QVector<TypeToCreate *> RealFactory::createVectorFromParameter(QString prefix, QString basename)
{
    // The vector of objects to return
    QVector<TypeToCreate *> objects;
    // Getting the vector of groups under prefix
    QStringList objectsGroups = m_configurationParameters.getGroupsWithPrefixList(prefix, basename);
    // Order the data, so that the index respect the number specified after the colon in the groupname
    qSort(objectsGroups.begin(), objectsGroups.end(), orderByNumberAfterColon);

    // Now creating all groups
    for (QStringList::iterator it = objectsGroups.begin(); it != objectsGroups.end(); it++) {
        objects.push_back(createFromParameter<TypeToCreate>(prefix + ConfigurationParameters::GroupSeparator() + *it));
    }

    return objects;
}

} // end namespace farsa

#endif