configuration/src/configurationnode.cpp

/***************************************************************************
 *   Copyright (C) 2008 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 "configurationnode.h"
#include "configurationparameters.h"
#include <memory>

namespace farsa {

ConfigurationNode::ConfigurationNode(ConfigurationNode *parent, QString name, bool caseSensitive) :
    m_parent(parent),
    m_caseSensitive(caseSensitive),
    m_name(((name == ConfigurationParameters::GroupSeparator()) || (name == ConfigurationParameters::ParentGroup())) ? QString() : name),
    m_nullNode(m_name.isNull() ? NULL : new ConfigurationNode(this, QString())),
    m_nullValue(),
    m_object(),
    m_children(),
    m_childrenkeys(),
    m_parameters(),
    m_parameterskeys(),
    m_objectParameters()
{
}

ConfigurationNode::~ConfigurationNode()
{
    // Removing the null node
    delete m_nullNode;

    // Removing everything
    clearAll();
}

QList<const ConfigurationNode*> ConfigurationNode::getAncestors() const
{
    if (isNull()) {
        return QList<const ConfigurationNode*>();
    }

    QList<const ConfigurationNode*> list;

    // If we have a parent, calling its getAncestors and appending us to the result
    if (m_parent != NULL) {
        list = m_parent->getAncestors();
    }

    list.append(this);

    return list;
}

QStringList ConfigurationNode::getAncestorsNames() const
{
    if (isNull()) {
        return QStringList();
    }

    QStringList list;

    // If we have a parent, calling its getAncestorsNames and appending us to the result, otherwise returning the
    // list with only the empty string (the root node is referenced using "")
    if (m_parent != NULL) {
        list = m_parent->getAncestorsNames();
        list.append(m_name);
    } else {
        list.append("");
    }

    return list;
}

QString ConfigurationNode::getFullName() const
{
    if (isNull()) {
        return QString();
    }

    // If we have a parent, calling its getFullName and prepending the result to our name
    if (m_parent != NULL) {
        return m_parent->getFullName() + ConfigurationParameters::GroupSeparator() + m_name;
    } else {
        return m_name;
    }
}

ConfigurationNode* ConfigurationNode::addNode(QString name)
{
    // Not adding the node if its name is NULL, the group separator or the parent node or if this is a null node
    if ((isNull()) || (name.isEmpty()) || (name == ConfigurationParameters::GroupSeparator()) || (name == ConfigurationParameters::ParentGroup())) {
        // The NULL node hasn't a NULL node inside, returning self
        return (isNull()) ? this : m_nullNode;
    }

    // Checking if a node with that name already exists
    foreach( QString child, m_children.keys() ) {
        if ( child.compare( name, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
            return m_children[child];
        }
    }

    std::auto_ptr<ConfigurationNode> newNode(new ConfigurationNode(this, name, m_caseSensitive));

    m_children.insert(name, newNode.get());
    m_childrenkeys.push_back(name);

    return newNode.release();
}

ConfigurationNode* ConfigurationNode::getNode(QString path)
{
    // Using the const version and a const_cast
    return const_cast<ConfigurationNode*>((const_cast<const ConfigurationNode*>(this))->getNode(path));
}

const ConfigurationNode* ConfigurationNode::getNode(QString path) const
{
    if (isNull()) {
        return this;
    }

    // Getting the first element of the path
    QString firstNode = path.section(ConfigurationParameters::GroupSeparator(), 0, 0, QString::SectionSkipEmpty);

    if (firstNode.isEmpty()) {
        // If the first node is the empty string (i.e. the whole path is the empty string) returning this

        return this;
    } else if (firstNode == ConfigurationParameters::ParentGroup()) {
        // The path points to our parent group, returning it (if we have no parent, returning self)

        return (m_parent == NULL) ? this : m_parent;
    } else {
        // Getting the first node from the list of my children and, if it exists, calling its getNode function
        foreach( QString child, m_children.keys() ) {
            if ( child.compare( firstNode, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                QString remainingPath = path.section(ConfigurationParameters::GroupSeparator(), 1, -1, QString::SectionSkipEmpty);
                return m_children[child]->getNode(remainingPath);
            }
        }
        // child not found
        m_nullNode->clearAll();
        return m_nullNode;
    }
}

bool ConfigurationNode::deleteNode(QString name)
{
    if (isNull()) {
        return false;
    }

    // Searching the element to remove
    foreach( QString child, m_children.keys() ) {
        if ( child.compare( name, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
            m_children.remove(child);
            m_childrenkeys.removeAll(name);
            return true;
        }
    }

    // If the node doesn't exist, returning false
    return false;
}

bool ConfigurationNode::renameNode(QString oldName, QString newName)
{
    if (isNull() || (newName.isEmpty()) || (newName == ConfigurationParameters::GroupSeparator()) || (newName == ConfigurationParameters::ParentGroup())) {
        return false;
    }
    
    // If the node doesn't exist, returning false
    QString oldCaseAwareName = QString();
    foreach( QString child, m_children.keys() ) {
        if ( child.compare( oldName, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
            oldCaseAwareName = child;
            break;
        }
    }
    if ( oldCaseAwareName.isEmpty() ) {
        return false;
    }

    // Take the element with oldName and re-insert it with newName
    ConfigurationNode* node = m_children.take(oldCaseAwareName);
    m_children.insert(newName, node);
    // change the name in the childrenkeys mantaining the order
    int id = m_childrenkeys.indexOf(oldCaseAwareName);
    m_childrenkeys.replace( id, newName );
    return true;
}

QList<ConfigurationNode*> ConfigurationNode::getChildrenNodesList()
{
    return m_children.values();
}

QStringList ConfigurationNode::getChildrenList() const
{
    return m_childrenkeys;
}

QStringList ConfigurationNode::getFilteredChildrenList(QRegExp filter) const
{
    return m_childrenkeys.filter(filter);
}

bool ConfigurationNode::setObjectForNode(QString path, ParameterSettable* object, ObjectCreationStatus status)
{
    // Getting the node for path
    ConfigurationNode* node = getNode(path);

    if (node->isNull()) {
        return false;
    }

    // Setting the object and its status
    if ((object != NULL) || (status == CreatingObject)) {
        node->m_object.object = object;
    }
    node->m_object.objectStatus = status;

    return true;
}

void ConfigurationNode::resetObject()
{
    m_object.object = NULL;
    m_object.objectStatus = ObjectNotCreated;
}

ConfigurationNode::ObjectAndStatus ConfigurationNode::getObjectForNode(QString path) const
{
    // Getting the node for path
    const ConfigurationNode* node = getNode(path);

    if (node->isNull()) {
        return ObjectAndStatus();
    }

    return node->m_object;
}

bool ConfigurationNode::addParameter(QString name)
{
    // Not adding the property if its name is NULL, the group separator, the parent group or if this is a null node
    if ((isNull()) || (name.isEmpty()) || (name == ConfigurationParameters::GroupSeparator()) || (name == ConfigurationParameters::ParentGroup())) {
        return false;
    }

    // Searching if a property with that name already exists
    foreach( QString parameter, m_parameters.keys() ) {
        if ( parameter.compare( name, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
            return false;
        }
    }
    // Adding the new parameter to the map with an empty value
    m_parameters.insert(name, QString(""));
    m_parameterskeys.push_back(name);
    return true;
}

QString ConfigurationNode::getValue(QString path, bool alsoMatchParents) const
{
    if (isNull()) {
        return QString();
    }

    // The value to return
    QString value = QString();

    // Getting the first element of the path and the remaining part of it
    QString firstPart = path.section(ConfigurationParameters::GroupSeparator(), 0, 0, QString::SectionSkipEmpty);
    QString remainingPath = path.section(ConfigurationParameters::GroupSeparator(), 1, -1, QString::SectionSkipEmpty);

    if (remainingPath.isEmpty()) {
        // This must be a parameter of mine, otherwise an error occurred
        foreach( QString parameter, m_parameters.keys() ) {
            if ( parameter.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                value = m_parameters[parameter];
                break;
            }
        }
    } else if (firstPart == ConfigurationParameters::ParentGroup()) {
        // Calling the function in parent group (calling it again on ourself if we don't have any parent group)

        const ConfigurationNode* const p = (m_parent == NULL) ? this : m_parent;
        return p->getValue(remainingPath, alsoMatchParents);
    } else {
        // The value of the parameter in the current node (used only if alsoMatchParents is true)
        QString currentParameterValue = QString();

        // If alsoMatchParents is true checking if we have that parameter before calling child nodes
        if (alsoMatchParents) {
            QString parameterName = path.section(ConfigurationParameters::GroupSeparator(), -1, -1, QString::SectionSkipEmpty);
            foreach( QString parameter, m_parameters.keys() ) {
                if ( parameter.compare( parameterName, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                    currentParameterValue = m_parameters[parameter];
                    break;
                }
            }
        }

        // Getting the first node from the list of my children and, if it exists, calling its getValue function
        foreach( QString child, m_children.keys() ) {
            if ( child.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                value = m_children[child]->getValue(remainingPath, alsoMatchParents);
                // If we also have to match the parameter in parents and the parameter wasn't found in children,
                // using our value
                if ((alsoMatchParents) && (value.isEmpty())) {
                    value = currentParameterValue;
                }
                break;
            }
        }
    }
    return value;
}

ConfigurationNode::ObjectAndStatus ConfigurationNode::getObject(QString path, bool alsoMatchParents) const
{
    if (isNull()) {
        return ObjectAndStatus();
    }

    // The value to return (the object field is set to NULL by the constructor)
    ObjectAndStatus object;

    // Getting the first element of the path and the remaining part of it
    QString firstPart = path.section(ConfigurationParameters::GroupSeparator(), 0, 0, QString::SectionSkipEmpty);
    QString remainingPath = path.section(ConfigurationParameters::GroupSeparator(), 1, -1, QString::SectionSkipEmpty);

    if (remainingPath.isEmpty()) {
        foreach( QString parameter, m_objectParameters.keys() ) {
            if ( parameter.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                object = m_objectParameters[parameter];
                break;
            }
        }
    } else if (firstPart == ConfigurationParameters::ParentGroup()) {
        // Calling the function in parent group (calling it again on ourself if we don't have any parent group)

        const ConfigurationNode* const p = (m_parent == NULL) ? this : m_parent;
        return p->getObject(remainingPath, alsoMatchParents);
    } else {
        // The value of the parameter in the current node (used only if alsoMatchParents is true)
        ObjectAndStatus currentParameterObject;

        // If alsoMatchParents is true checking if we have that parameter before calling child nodes
        if (alsoMatchParents) {
            QString parameterName = path.section(ConfigurationParameters::GroupSeparator(), -1, -1, QString::SectionSkipEmpty);
            foreach( QString parameter, m_objectParameters.keys() ) {
                if ( parameter.compare( parameterName, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                    currentParameterObject = m_objectParameters[parameter];
                    break;
                }
            }
        }

        // Getting the first node from the list of my children and, if it exists, calling its getObject function
        foreach( QString child, m_children.keys() ) {
            if ( child.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                object = m_children[child]->getObject(remainingPath, alsoMatchParents);
                // If we also have to match the parameter in parents and the parameter wasn't found in children,
                // using our value
                if ((alsoMatchParents) && (object.object == NULL)) {
                    object = currentParameterObject;
                }
                break;
            }
        }
    }

    return object;
}

bool ConfigurationNode::setValue(QString path, QString value)
{
    if (isNull()) {
        return false;
    }

    // Getting the first element of the path and the remaining part of it
    QString firstPart = path.section(ConfigurationParameters::GroupSeparator(), 0, 0, QString::SectionSkipEmpty);
    QString remainingPath = path.section(ConfigurationParameters::GroupSeparator(), 1, -1, QString::SectionSkipEmpty);

    if (remainingPath.isEmpty()) {
        // This must be a parameter of mine, otherwise an error occurred
        foreach( QString parameter, m_parameters.keys() ) {
            if ( parameter.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                m_parameters[parameter] = value;
                return true;
            }
        }
        return false;
    } else if (firstPart == ConfigurationParameters::ParentGroup()) {
        // Calling the function in parent group (calling it again on ourself if we don't have any parent group)

        ConfigurationNode* const p = (m_parent == NULL) ? this : m_parent;
        return p->setValue(remainingPath, value);
    } else {
        // Getting the first node from the list of my children and, if it exists, calling its setValue function
        foreach( QString child, m_children.keys() ) {
            if ( child.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                return m_children[child]->setValue(remainingPath, value);
            }
        }
        return false;
    }
}

bool ConfigurationNode::setValue(QString path, ParameterSettable* object)
{
    if (isNull()) {
        return false;
    }

    // Getting the first element of the path and the remaining part of it
    QString firstPart = path.section(ConfigurationParameters::GroupSeparator(), 0, 0, QString::SectionSkipEmpty);
    QString remainingPath = path.section(ConfigurationParameters::GroupSeparator(), 1, -1, QString::SectionSkipEmpty);

    if (remainingPath.isEmpty()) {
        // This must be a parameter of mine, otherwise an error occurred
        foreach( QString parameter, m_parameters.keys() ) {
            if ( parameter.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                m_parameters[parameter] = QString(" ");
                // Saving the reference to the object into the m_objectParameters map
                m_objectParameters[parameter].object = object;
                m_objectParameters[parameter].objectStatus = ObjectCreatedAndConfigured;
                return true;
            }
        }
        return false;
    } else if (firstPart == ConfigurationParameters::ParentGroup()) {
        // Calling the function in parent group (calling it again on ourself if we don't have any parent group)

        ConfigurationNode* const p = (m_parent == NULL) ? this : m_parent;
        return p->setValue(remainingPath, object);
    } else {
        // Getting the first node from the list of my children and, if it exists, calling its setValue function
        foreach( QString child, m_children.keys() ) {
            if ( child.compare( firstPart, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
                return m_children[child]->setValue(remainingPath, object);
            }
        }
        return false;
    }
}

bool ConfigurationNode::deleteParameter(QString name)
{
    if (isNull()) {
        return false;
    }

    // Searching the element to remove
    foreach( QString parameter, m_parameters.keys() ) {
        if ( parameter.compare( name, (m_caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
            m_parameters.remove( parameter );
            m_parameterskeys.removeAll( parameter );
            return true;
        }
    }
    return false;
}

QStringList ConfigurationNode::getParametersList() const
{
    // NULL nodes have no parameters, so this returns an empty list
    return m_parameterskeys;
}

QStringList ConfigurationNode::getFilteredParametersList(QRegExp filter) const
{
    return m_parameterskeys.filter(filter);
}

QStringList ConfigurationNode::getObjectParametersList() const
{
    // NULL nodes have no parameters, so this returns an empty list
    return QStringList(m_objectParameters.keys());
}

QStringList ConfigurationNode::getFilteredObjectParametersList(QRegExp filter) const
{
    return QStringList(m_objectParameters.keys()).filter(filter);
}

void ConfigurationNode::clearAll()
{
    if (isNull()) {
        return;
    }

    // Removing all child nodes
    for (QMap<QString, ConfigurationNode*>::iterator it = m_children.begin(); it != m_children.end(); it++) {
        delete it.value();
    }
    m_children.clear();
    m_childrenkeys.clear();

    // Removing all parameters
    m_parameters.clear();
    m_parameterskeys.clear();
}

} // end namespace farsa