configurationparameters.h

/***************************************************************************
 *   Copyright (C) 2008-2009 by 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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef CONFIGURATION_PARAMETERS_H
#define CONFIGURATION_PARAMETERS_H

#include "configurationconfig.h"
#include <QMap>
#include <QString>
#include <QRegExp>
#include <QStringList>
#include <QList>
#include <memory>
#include "parametersfileloadersaver.h"
#include "resourcesuser.h"

namespace farsa {

class RealFactory;
class ParameterSettable;
class ParameterSettableWithConfigureFunction;
class ConfigurationNode;
class FactoryObserver;

class FARSA_CONF_API ConfigurationParameters
{
public:
    static QString GroupSeparator() { return QString("/"); };

    static QString ParentGroup() { return QString(".."); };

    static bool registerFileFormat(QString format, ParametersFileLoaderSaver *fileLoaderSaver, QString defaultExtension);

private:
    struct FileFormat
    {
        FileFormat(const QString &f, ParametersFileLoaderSaver *l, const QString &e) :
            formatName(f),
            fileLoaderSaver(l),
            extension(e),
            m_destructionResponsability(true)
        {
        }

        FileFormat(const FileFormat& other) :
            formatName(other.formatName),
            fileLoaderSaver(other.fileLoaderSaver),
            extension(other.extension),
            m_destructionResponsability(other.m_destructionResponsability)
        {
            // Releasing copied object from destruction
            // responsability
            other.m_destructionResponsability = false;
        }

        FileFormat& operator=(const FileFormat &other)
        {
            // Checking for self-assignment
            if (&other == this) {
                return *this;
            }

            formatName = other.formatName;
            fileLoaderSaver = other.fileLoaderSaver;
            extension = other.extension;
            m_destructionResponsability = other.m_destructionResponsability;

            // Releasing copied object from destruction
            // responsability
            other.m_destructionResponsability = false;

            return *this;
        }

        ~FileFormat()
        {
            // Destroying if we have to
            if (m_destructionResponsability) {
                delete fileLoaderSaver;
            }
        }

        QString formatName;

        ParametersFileLoaderSaver *fileLoaderSaver;

        QString extension;

    private:
        mutable bool m_destructionResponsability;
    };

    static QMap<QString, FileFormat>& getFormatsMap();

    static QMap<QString, QString>& getFileExtensionsMap();

public:
    ConfigurationParameters(bool caseSensitive = false);

    ConfigurationParameters(const ConfigurationParameters &other);

    ConfigurationParameters& operator=(const ConfigurationParameters &other);

    ~ConfigurationParameters();

    bool isCaseSensitive() const;

    void clearAll();

    QStringList getGroupsList(QString group) const;

    QStringList getGroupsWithPrefixList(QString group, QString prefix) const;

    QStringList getFilteredGroupsList(QString group, QRegExp filter) const;

    void createGroup(QString groupPath);

    bool deleteGroup(QString groupPath);

    bool renameGroup(QString oldGroupPath, QString newGroupName);

    QString createSubGroup(QString parentPath, QString groupName) {
        QString fullpath = parentPath + GroupSeparator() + groupName;
        createGroup( fullpath );
        return fullpath;
    };

    void createParameter(QString groupPath, QString parameter);

    void createParameter(QString groupPath, QString parameter, QString value)
    {
        createParameter(groupPath, parameter);
        setValue(groupPath + GroupSeparator() + parameter, value);
    }

    void createParameter(QString groupPath, QString parameter, ParameterSettable* object)
    {
        createParameter(groupPath, parameter);
        setValue(groupPath + GroupSeparator() + parameter, object);
    }

    void deleteParameter(QString groupPath, QString parameter);

    bool startObjectParameters(QString groupPath, QString typeName, ParameterSettable* object);

    QString getValue(QString path, bool alsoMatchParents = false) const;

    bool setValue(QString path, QString value);

    bool setValue(QString path, ParameterSettable* object);

    QStringList getParametersList(QString group) const;

    QStringList getParametersWithPrefixList(QString group, QString prefix) const;

    QStringList getFilteredParametersList(QString group, QRegExp filter) const;

    void startRememberingGroupObjectAssociations();

    void stopRememberingGroupObjectAssociations();

    void resetGroupObjectAssociations();

    template <class TypeToCreate>
    TypeToCreate* getObjectFromGroup(QString group, bool configure = true, bool forceObjectCreation = false);

    template <class TypeToCreate>
    TypeToCreate* getObjectFromParameter(QString param, bool alsoMatchParents = false, bool configure = true, bool forceObjectCreation = false)
    {
        // Getting the value for the parameter and calling getObjectFromGroup
        QString value = getValue(param, alsoMatchParents);
        // Checking this here because calling getObjectFromGroup with an
        // empty or null string means root group
        if (value.isEmpty()) {
            return NULL;
        }
        return getObjectFromGroup<TypeToCreate>(value, configure, forceObjectCreation);
    }

    void updateObjectReferences();

    bool loadParameters(QString filename, bool keepOld = false, QString format = "");

    bool saveParameters(QString filename, QString format = "", bool append = false);

    SimpleResourcesUser* getResourcesUserForResource(QString resourceName);

    void setResourcesUser(ResourcesUser* resourcesUser);

    void addObserver(FactoryObserver* observer);
    
    void shareObserversWith( ConfigurationParameters& params );

private:
    QString formatFromFilenameExtension(QString filename) const;

    void copyTree(const ConfigurationNode *root);

    void copyNode(const ConfigurationNode *source, ConfigurationNode *target);

    bool setObjectFromGroupStatusToCreating(QString group);

    bool setObjectFromGroupStatusToCreatedNotConfigured(QString group, ParameterSettable *object);

    bool setObjectFromGroupStatusToConfiguring(QString group);

    bool setObjectFromGroupStatusToCreatingAndConfiguring(QString group);

    bool setObjectFromGroupStatusToCreatedAndConfigured(QString group, ParameterSettable *object = NULL);

    bool outsideCallsToGetObjectFromGroup() const
    {
        return (m_getObjectFromGroupRecursionLevel == 0);
    }

    const std::auto_ptr<RealFactory> m_factory;

    std::auto_ptr<ConfigurationNode> m_root;

    unsigned int m_getObjectFromGroupRecursionLevel;

    struct ObjectAndRecursionLevel
    {
        ParameterSettableWithConfigureFunction* object;

        unsigned int recursionLevel;

        QString groupName;
    };

    QList<ObjectAndRecursionLevel> m_objectsToConfigure;

    bool m_dontForgetGroupObjectAssociations;

    QList<SimpleResourcesUser> m_resourcesUserPerRecursionLevel;

    template<class T, bool ConfigureInConstructor>
    friend class ParameterSettableCreatorT;

    friend class RealFactory;
};

} // end namespace farsa

// Implementation of template functions
#include "configurationnode.h"
#include "parametersettable.h"
#include "realfactory.h"
#include <memory>

namespace farsa {

template <class TypeToCreate>
TypeToCreate* ConfigurationParameters::getObjectFromGroup(QString group, bool configure, bool forceObjectCreation)
{
    // This is a simple class to implement RAII for the m_getObjectFromGroupRecursionLevel variable
    // and the m_objectsToConfigure list so that they are properly finalized on getObjectFromGroup() exit.
    // Note that to configure objects you have to explicitly call "release", the destructor doesn't call
    // configure on objects. This also manages m_resouceMangerPerRecursionLevel
    class RecursionLevelRAII
    {
    public:
        RecursionLevelRAII(unsigned int *var, QList<ConfigurationParameters::ObjectAndRecursionLevel> *list, QList<SimpleResourcesUser> *resourcesUsers, ConfigurationParameters &params, RealFactory& factory) :
            m_var(var),
            m_list(list),
            m_resourcesUsers(resourcesUsers),
            m_params(params),
            m_factory(factory)
        {
            (*m_var)++;
            m_resourcesUsers->append(SimpleResourcesUser());
        }

        // This doesn't throw because in the release function we don't call configure
        ~RecursionLevelRAII() throw()
        {
            release(false);
        }

        void release(bool doConfigure = true)
        {
            if (m_list != NULL) {
                while ((!m_list->isEmpty()) && (m_list->back().recursionLevel > (*m_var))) {
                    if (doConfigure) {
                        // Calling configure (appending the separator to the group name)
                        m_list->back().object->configure(m_params, m_list->back().groupName + GroupSeparator());
                        // Telling the factory that the object has been configured
                        m_factory.objectConfigured(m_list->back().object);
                    }
                    m_list->pop_back();
                }
                m_list = NULL;
            }
            if (m_var != NULL) {
                (*m_var)--;
                m_var = NULL;
                m_resourcesUsers->removeLast();
            }
        }

    private:
        unsigned int *m_var;
        QList<ObjectAndRecursionLevel> *m_list;
        QList<SimpleResourcesUser> *m_resourcesUsers;
        ConfigurationParameters& m_params;
        RealFactory& m_factory;

        // We put implementations to avoid warning under windows. Anyway, these are private, so
        // nobody can call them. The initialization of m_params is to avoid compilation errors
        // under MSVC
        RecursionLevelRAII(const RecursionLevelRAII& other) : m_params(*((ConfigurationParameters *) NULL)), m_factory(*((RealFactory *) NULL)) {}
        RecursionLevelRAII& operator=(const RecursionLevelRAII& other) { return *this; }
    };

    // First of all getting the node for the group
    ConfigurationNode *node = m_root->getNode(group);

    // If the node doesn't exist, returning NULL
    if (node == NULL) {
        return NULL;
    }

    // Before starting with group creation, resetting all associations between nodes and objects
    if ((!m_dontForgetGroupObjectAssociations) && (m_getObjectFromGroupRecursionLevel == 0)) {
        resetGroupObjectAssociations();
    }

    // If the recursion level is 0 (this is the most external call to getObjectFromGroup), we always configure
    // the object. This check is needed because otherwise, if the most external call to this function has
    // the configure parameter set to false, the object returned by that call is never configured
    if (m_getObjectFromGroupRecursionLevel == 0) {
        configure = true;
    }

    // Incrementing the recursion level for this function
    RecursionLevelRAII recursionLevelRAII(&m_getObjectFromGroupRecursionLevel, &m_objectsToConfigure, &m_resourcesUserPerRecursionLevel, *this, *m_factory);

    // The pointer to return
    TypeToCreate* retObj = NULL;
    // This is used only if the object is created during this call
    std::auto_ptr<TypeToCreate> retObjRAII(NULL);

    // Now checking if an object is already associated with the node and its status
    ConfigurationNode::ObjectAndStatus object = node->getObjectForNode("");
    // This is set to true because we use it to decide whether to add the object to the list or not:
    // if true it is not added, if false it is added (an this is only modified when the object is created
    // using the factory)
    bool actuallyConfigured = true;
    switch (object.objectStatus) {
        case ObjectNotCreated:
            // Creating object
            retObj = m_factory->createFromParameter<TypeToCreate>(group, configure, &actuallyConfigured);
            retObjRAII.reset(retObj);
            break;
        case CreatingObject:
            // Object is in creation phase, cannot return it and cannot create another object (throwning
            // a different exception depending on the situation)
            if (forceObjectCreation) {
                throw OtherObjectBeingCreatedException(group.toAscii().data());
            } else {
                throw CyclicDependencyException(group.toAscii().data());
            }
            break;
        case ObjectCreatedNotConfigured:
            // Checking we haven't been requested a new object (we cannot do this because another object exists
            // but is not configured - this is the safest policy, even if perhaps we could do something more smart).
            if (forceObjectCreation) {
                throw OtherObjectBeingCreatedException(group.toAscii().data());
            }
            // Now we can configure the object if we have to and then return the object
            retObj = dynamic_cast<TypeToCreate *>(object.object);
            if (retObj == NULL) {
                throw CannotConvertToTypeException(typeid(object.object).name(), typeid(TypeToCreate));
            }
            if (configure) {
                // If we are here the object is surely of type ParameterSettableWithConfigureFunction
                // (otherwise the cast will fail miserably). We also change the state of the object before
                // and after configuration. Despite having casted object.object to TypeToCreate we use
                // another cast here because otherwise we would have compilation errors with classes
                // deriving from ParameterSettableInConstructor (but with those classes we should never
                // get here)
                node->setObjectForNode("", retObj, ConfiguringObject);
                ParameterSettableWithConfigureFunction *const o = dynamic_cast<ParameterSettableWithConfigureFunction *>(retObj);
                o->configure(*this, group);
                // Telling the factory that the object has been configured
                m_factory->objectConfigured(o);
                node->setObjectForNode("", retObj, ObjectCreatedAndConfigured);
            }
            break;
        case ConfiguringObject:
            // Checking we haven't been requested a new object (we cannot do this because another object exists
            // and is being configured - this is the safest policy, even if perhaps we could do something more smart).
            if (forceObjectCreation) {
                throw OtherObjectBeingCreatedException(group.toAscii().data());
            }
            if (configure) {
                // Object is in configuration phase, cannot return it
                throw CyclicDependencyException(group.toAscii().data());
            } else {
                // Ok, returning object
                retObj = dynamic_cast<TypeToCreate *>(object.object);
                if (retObj == NULL) {
                    throw CannotConvertToTypeException(typeid(object.object).name(), typeid(TypeToCreate));
                }
            }
            break;
        case CreatingAndConfiguringObject:
            // Object is in creation and configuration phase, cannot return it and cannot create another object
            // (throwning a different exception depending on the situation)
            if (forceObjectCreation) {
                throw OtherObjectBeingCreatedException(group.toAscii().data());
            } else {
                throw CyclicDependencyException(group.toAscii().data());
            }
            break;
        case ObjectCreatedAndConfigured:
            // If we were requested a new object, creating it, otherwise we return the already existing one
            if (forceObjectCreation) {
                // Creating object. This will also remove association with the previous object
                retObj = m_factory->createFromParameter<TypeToCreate>(group, configure, &actuallyConfigured);
                retObjRAII.reset(retObj);
            } else {
                // Ok, returning object
                retObj = dynamic_cast<TypeToCreate *>(object.object);
                if (retObj == NULL) {
                    throw CannotConvertToTypeException(typeid(object.object).name(), typeid(TypeToCreate));
                }
            }
            break;
    }

    // If the object has been created and not configured, appending to the list
    if (!actuallyConfigured) {
        ObjectAndRecursionLevel o;
        o.object = dynamic_cast<ParameterSettableWithConfigureFunction *>(retObj);
        o.recursionLevel = m_getObjectFromGroupRecursionLevel;
        o.groupName = group;
        m_objectsToConfigure.push_back(o);
    }

    // Releasing resources (explicitly, so that unconfigured objects that can be configured at this recursion level
    // will actually be configured)
    recursionLevelRAII.release();

    // Now checking if we have to call postConfigureInitialization() for all configured objects. The check is here (as
    // well as inside RealFactory::create) because this function can call RealFactory::create and vice-versa, so we have to check
    // which of the two is the most external call
    // NOTE: now that the factory cannot be used directly this check should be useless (we always call postConfigureInitialization()
    //       here. Leaving it here, however, creates no harm (so, just to be sure, we don't touch it)
    if (m_factory->outsideCallsToCreate() && (m_getObjectFromGroupRecursionLevel == 0)) {
        m_factory->callPostConfigureInitializationForConfiguredObjects();

        // Safety check, just to be sure: when we get here, there should be no object in the list of objects yet to configure
        if (m_objectsToConfigure.size() != 0) {
            qFatal( "INTERNAL ERROR: The list of objects yet to be configured is not empty at the exit of the most external call to ConfigurationParameters::getObjectFromGroup(). The number of objects still in the list is %d", m_objectsToConfigure.size());
        }
    }

    retObjRAII.release();
    return retObj;
}

} // end namespace farsa

#endif