configurationparameters.cpp

/***************************************************************************
 *   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.             *
 ***************************************************************************/

#include "realfactory.h"
#include "configurationnode.h"
#include "configurationparameters.h"
#include "parametersfileloadersaver.h"
#include "parametersettable.h"
#include "configurationexceptions.h"
#include <QFileInfo>
#include <QQueue>
#include <memory>

namespace farsa {

QMap<QString, ConfigurationParameters::FileFormat>& ConfigurationParameters::getFormatsMap()
{
    static QMap<QString, ConfigurationParameters::FileFormat> formatsMap;

    return formatsMap;
}

QMap<QString, QString>& ConfigurationParameters::getFileExtensionsMap()
{
    static QMap<QString, QString> fileExtensionsMap;

    return fileExtensionsMap;
}

bool ConfigurationParameters::registerFileFormat(QString format, ParametersFileLoaderSaver *fileLoaderSaver, QString defaultExtension)
{
    // Checking whether the format already exists
    QMap<QString, FileFormat>::iterator it = getFormatsMap().find(format);
    if (it != getFormatsMap().end()) {
        return false;
    }

    // If defaultExtension is the empty string, changing it to format
    if (defaultExtension.isEmpty()) {
        defaultExtension = format;
    }

    // Filling the structure with format informations
    FileFormat f(format, fileLoaderSaver, defaultExtension);

    // Adding format to maps
    getFormatsMap().insert(format, f);
    getFileExtensionsMap().insert(defaultExtension, format);

    return true;
}

ConfigurationParameters::ConfigurationParameters(bool caseSensitive) :
    m_factory(new RealFactory(*this)),
    m_root(new ConfigurationNode(NULL, "", caseSensitive)),
    m_getObjectFromGroupRecursionLevel(0),
    m_objectsToConfigure(),
    m_dontForgetGroupObjectAssociations(false),
    m_resourcesUserPerRecursionLevel(QList<SimpleResourcesUser>() << SimpleResourcesUser())
{
}

ConfigurationParameters::ConfigurationParameters(const ConfigurationParameters &other) :
    m_factory(new RealFactory(*this)),
    m_root(new ConfigurationNode(NULL, "", true)),
    m_getObjectFromGroupRecursionLevel(0),
    m_objectsToConfigure(),
    m_dontForgetGroupObjectAssociations(false),
    m_resourcesUserPerRecursionLevel(QList<SimpleResourcesUser>() << SimpleResourcesUser())
{
    // Copying the tree
    copyTree(other.m_root.get());
}

ConfigurationParameters& ConfigurationParameters::operator=(const ConfigurationParameters &other)
{
    // Checking that we are not in a call to getObjectFromGroup
    if (m_getObjectFromGroupRecursionLevel != 0) {
        throw CopyDuringObjectCreationException();
    }

    // Checking for self-assignement
    if (&other == this) {
        return *this;
    }

    // Copying the tree (this removes the previous one)
    copyTree(other.m_root.get());

    // Now also substituting all observers
    m_factory->clearObservers();
    m_factory->addObservers(other.m_factory->getObservers());

    return *this;
}

ConfigurationParameters::~ConfigurationParameters()
{
    // Nothing to do here, we use auto_ptr
}

bool ConfigurationParameters::isCaseSensitive() const
{
    return m_root->isCaseSensitive();
}

void ConfigurationParameters::clearAll()
{
    m_root->clearAll();
}

QStringList ConfigurationParameters::getGroupsList(QString group) const
{
    return m_root->getNode(group)->getChildrenList();
}

QStringList ConfigurationParameters::getGroupsWithPrefixList(QString group, QString prefix) const
{
    // Building the regular expression matching the given prefix
    QRegExp filter(QString("^") + QRegExp::escape(prefix), (isCaseSensitive() ? Qt::CaseSensitive : Qt::CaseInsensitive));

    return getFilteredGroupsList(group, filter);
}

QStringList ConfigurationParameters::getFilteredGroupsList(QString group, QRegExp filter) const
{
    return m_root->getNode(group)->getFilteredChildrenList(filter);
}

void ConfigurationParameters::createGroup(QString groupPath)
{
    // Splitting path
    QStringList splittedPath = groupPath.split(ConfigurationParameters::GroupSeparator(), QString::SkipEmptyParts, Qt::CaseSensitive);

    // Now creating all nodes
    ConfigurationNode* lastNode = m_root.get();
    for (QStringList::iterator it = splittedPath.begin(); it != splittedPath.end(); it++) {
        lastNode = lastNode->addNode(*it);
    }
}

bool ConfigurationParameters::deleteGroup(QString groupPath)
{
    //--- extract the group name
    QString groupName = groupPath.section( ConfigurationParameters::GroupSeparator(), -1 );
    //--- extract the path 
    QString groupParent = groupPath.section( ConfigurationParameters::GroupSeparator(), 0, -2 );
    return m_root->getNode(groupParent)->deleteNode(groupName);
}

bool ConfigurationParameters::renameGroup(QString oldGroupPath, QString newGroupName)
{
    //--- extract the group name
    QString groupName = oldGroupPath.section( ConfigurationParameters::GroupSeparator(), -1 );
    //--- extract the path 
    QString groupParent = oldGroupPath.section( ConfigurationParameters::GroupSeparator(), 0, -2 );
    return m_root->getNode(groupParent)->renameNode(groupName, newGroupName);
}

bool ConfigurationParameters::copyGroupTree(QString sourceGroup, QString destGroup) {
    ConfigurationNode* sourceNode = m_root->getNode( sourceGroup );
    if ( sourceNode->isNull() ) {
        return false;
    }
    ConfigurationNode* destNode = m_root->getNode( destGroup );
    if ( destNode->isNull() ) {
        // create the destination node
        createGroup( destGroup );
        destNode = m_root->getNode( destGroup );
    }
    copyNode( sourceNode, destNode );
    return true;
}

void ConfigurationParameters::createParameter(QString groupPath, QString parameter)
{
    ConfigurationNode* node = m_root->getNode(groupPath);
    if ( !node->isNull() ) {
        node->addParameter( parameter );
    }
}

void ConfigurationParameters::deleteParameter(QString groupPath, QString parameter) {
    ConfigurationNode* node = m_root->getNode(groupPath);
    if ( !node->isNull() ) {
        node->deleteParameter( parameter );
    }
}

bool ConfigurationParameters::startObjectParameters(QString groupPath, QString typeName, ParameterSettable* object)
{
    // Creating the group
    createGroup(groupPath);

    // Then adding the "type" parameter
    createParameter(groupPath, QString("type"), typeName);

    // Now setting the object corresponding to the given group to object
    return m_root->setObjectForNode(groupPath, object);
}

QString ConfigurationParameters::getValue(QString path, bool alsoMatchParents) const
{
    return m_root->getValue(path, alsoMatchParents);
}

bool ConfigurationParameters::setValue(QString path, QString value)
{
    return m_root->setValue(path, value);
}

bool ConfigurationParameters::setValue(QString path, ParameterSettable* object)
{
    return m_root->setValue(path, object);
}

QStringList ConfigurationParameters::getParametersList(QString group) const
{
    return m_root->getNode(group)->getParametersList();
}

QStringList ConfigurationParameters::getParametersWithPrefixList(QString group, QString prefix) const
{
    // Building the regular expression matching the given prefix
    QRegExp filter(QString("^") + QRegExp::escape(prefix), (isCaseSensitive() ? Qt::CaseSensitive : Qt::CaseInsensitive));

    return getFilteredParametersList(group, filter);
}

QStringList ConfigurationParameters::getFilteredParametersList(QString group, QRegExp filter) const
{
    return m_root->getNode(group)->getFilteredParametersList(filter);
}

void ConfigurationParameters::startRememberingGroupObjectAssociations()
{
    m_dontForgetGroupObjectAssociations = true;
}

void ConfigurationParameters::stopRememberingGroupObjectAssociations()
{
    m_dontForgetGroupObjectAssociations = false;
}

void ConfigurationParameters::resetGroupObjectAssociations()
{
    // Descending the tree and calling resetObject on all nodes
    QQueue<ConfigurationNode *> nodeQueue;
    nodeQueue.enqueue(m_root.get());

    // Now descending the tree
    while (!nodeQueue.isEmpty()) {
        // Getting a node and calling resetObject on it
        ConfigurationNode *curNode = nodeQueue.dequeue();
        curNode->resetObject();

        // Now adding all children of current node to the queue
        #if QT_VERSION_CHECK > 0x450000
            nodeQueue.append(curNode->getChildrenNodesList());
        #else
            foreach( ConfigurationNode* an, curNode->getChildrenNodesList() ) {
                nodeQueue.append( an );
            }
        #endif
    }
}

void ConfigurationParameters::updateObjectReferences()
{
    // We perform the update in two steps: first of all we create a map from pointers to group paths;
    // then we search the whole tree for object parameters and set them

    // First step: descending the tree and creating the map
    QMap<ParameterSettable *, QString> objectsMap;
    QQueue<ConfigurationNode *> nodeQueue;
    nodeQueue.enqueue(m_root.get());

    // Now descending the tree
    while (!nodeQueue.isEmpty()) {
        // Getting a node and the object for that node
        ConfigurationNode *curNode = nodeQueue.dequeue();
        ConfigurationNode::ObjectAndStatus object = curNode->getObjectForNode("");

        if (object.object != NULL) {
            // Adding to map
            // --- when saving an object reference parameter, the first GroupSeparator() will
            //     be removed to avoid to save something like that:
            // object = /groupPath/nameOfObject
            //    instead of
            // object = groupPath/nameOfObject
            QString fullname = curNode->getFullName();
            if ( fullname.startsWith( GroupSeparator() ) ) {
                fullname.remove( 0, 1 );
            }
            objectsMap[object.object] = fullname; //curNode->getFullName();
        }

        // Now adding all children of current node to the queue
        #if QT_VERSION_CHECK > 0x450000
            nodeQueue.append(curNode->getChildrenNodesList());
        #else
            foreach( ConfigurationNode* an, curNode->getChildrenNodesList() ) {
                nodeQueue.append( an );
            }
        #endif
    }

    // We have the list of objects and their path, now searching all object parameters
    // and setting them (we re-use nodeQueue to descend the tree, it is empty for sure)
    nodeQueue.enqueue(m_root.get());

    // Descending the tree one more time
    while (!nodeQueue.isEmpty()) {
        // Getting a node
        ConfigurationNode *curNode = nodeQueue.dequeue();

        // Obtaining the list of object parameters
        QStringList params = curNode->getObjectParametersList();

        for (QStringList::iterator it = params.begin(); it != params.end(); it++) {
            // Getting the object for the parameter
            ParameterSettable *obj = curNode->getObject(*it).object;

            // If we have a pointer to obj in the map, setting the value for the parameter
            if (objectsMap.contains(obj)) {
                curNode->setValue(*it, objectsMap[obj]);
            } else {
                curNode->setValue(*it, QString(""));
            }
        }

        // Now adding all children of current node to the queue
        #if QT_VERSION_CHECK > 0x450000
            nodeQueue.append(curNode->getChildrenNodesList());
        #else
            foreach( ConfigurationNode* an, curNode->getChildrenNodesList() ) {
                nodeQueue.append( an );
            }
        #endif
    }
}

bool ConfigurationParameters::loadParameters(QString filename, bool keepOld, QString format)
{
    // If format is the empty string, guessing it from filename extension
    if (format.isEmpty()) {
        format = formatFromFilenameExtension(filename);

        if (format.isNull()) {
            return false;
        }
    }

    // Searching the format on the map
    QMap<QString, FileFormat>::iterator it = getFormatsMap().find(format);

    // If not found, returning false
    if (it == getFormatsMap().end()) {
        return false;
    }

    return it->fileLoaderSaver->load( filename, *this, keepOld );
}

bool ConfigurationParameters::saveParameters(QString filename, QString format, bool append)
{
    // Before saving updating all object references
    updateObjectReferences();

    // If format is the empty string, guessing it from filename extension
    if (format.isEmpty()) {
        format = formatFromFilenameExtension(filename);

        if (format.isNull()) {
            return false;
        }
    }

    // Searching the format on the map
    QMap<QString, FileFormat>::iterator it = getFormatsMap().find(format);

    // If not found, returning false
    if (it == getFormatsMap().end()) {
        return false;
    }

    return it->fileLoaderSaver->save( filename, *this, append );
}

SimpleResourcesUser* ConfigurationParameters::getResourcesUserForResource(QString resourceName)
{
    // Searching the ResourceManager containing the given resource
    for (int i = m_getObjectFromGroupRecursionLevel; i >= 0; i--) {
        if (m_resourcesUserPerRecursionLevel[i].hasResource(resourceName)) {
            return &(m_resourcesUserPerRecursionLevel[i]);
        }
    }

    return NULL;
}

void ConfigurationParameters::setResourcesUser(ResourcesUser* resourcesUser)
{
    m_resourcesUserPerRecursionLevel.last().shareResourcesWith(resourcesUser);
}

void ConfigurationParameters::addObserver(FactoryObserver* observer)
{
    m_factory->addObserver(observer);
}

void ConfigurationParameters::shareObserversWith( ConfigurationParameters& params ) {
    m_factory->addObservers( params.m_factory->getObservers() );
}

QString ConfigurationParameters::formatFromFilenameExtension(QString filename) const
{
    QFileInfo info(filename);

    QMap<QString, QString>::const_iterator it = getFileExtensionsMap().find(info.suffix());
    if (it == getFileExtensionsMap().end()) {
        return QString();
    } else {
        return *it;
    }
}

void ConfigurationParameters::copyTree(const ConfigurationNode *root)
{
    // Allocating root. Parent is not copied as we suppose root to be a root of a tree
    m_root.reset(new ConfigurationNode(NULL, root->getName(), root->isCaseSensitive()));

    // Now recursively copying the tree
    copyNode(root, m_root.get());
}

void ConfigurationParameters::copyNode(const ConfigurationNode *source, ConfigurationNode *target)
{
    // First copying all parameters
    QStringList params = source->getParametersList();
    for (QStringList::const_iterator it = params.begin(); it != params.end(); it++) {
        target->addParameter(*it);
        target->setValue(*it, source->getValue(*it));
    }

    // We don't copy the object associated to the node

    // Now creating children in target and recursively filling them
    QStringList children = source->getChildrenList();
    for (QStringList::const_iterator it = children.begin(); it != children.end(); it++) {
        target->addNode(*it);
        copyNode(source->getNode(*it), target->getNode(*it));
    }
}

bool ConfigurationParameters::setObjectFromGroupStatusToCreating(QString group)
{
    if (m_getObjectFromGroupRecursionLevel == 0) {
        return true;
    }
    return m_root->setObjectForNode(group, NULL, CreatingObject);
}

bool ConfigurationParameters::setObjectFromGroupStatusToCreatedNotConfigured(QString group, ParameterSettable *object)
{
    if (m_getObjectFromGroupRecursionLevel == 0) {
        return true;
    }
    return m_root->setObjectForNode(group, object, ObjectCreatedNotConfigured);
}

bool ConfigurationParameters::setObjectFromGroupStatusToConfiguring(QString group)
{
    if (m_getObjectFromGroupRecursionLevel == 0) {
        return true;
    }
    return m_root->setObjectForNode(group, NULL, ConfiguringObject);
}

bool ConfigurationParameters::setObjectFromGroupStatusToCreatingAndConfiguring(QString group)
{
    if (m_getObjectFromGroupRecursionLevel == 0) {
        return true;
    }
    return m_root->setObjectForNode(group, NULL, CreatingAndConfiguringObject);
}

bool ConfigurationParameters::setObjectFromGroupStatusToCreatedAndConfigured(QString group, ParameterSettable *object)
{
    if (m_getObjectFromGroupRecursionLevel == 0) {
        return true;
    }
    return m_root->setObjectForNode(group, object, ObjectCreatedAndConfigured);
}

} // end namespace farsa