configurationhelper.cpp

/***************************************************************************
 *   Copyright (C) 2008-2011 by Tomassino Ferrauto, Gianluca Massera       *
 *   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 "configurationhelper.h"
#include "configurationexceptions.h"

namespace farsa {

int ConfigurationHelper::getInt( ConfigurationParameters& params, QString paramPath, int def ) {
    QString str = params.getValue(paramPath);
    if ( str.isEmpty() ) return def;
    bool ok;
    int ret = str.toInt(&ok);
    if (!ok) {
        return def;
    }
    return ret;
}

unsigned int ConfigurationHelper::getUnsignedInt( ConfigurationParameters& params, QString paramPath, unsigned int def ) {
    QString str = params.getValue(paramPath);
    if ( str.isEmpty() ) return def;
    bool ok;
    unsigned int ret = str.toUInt(&ok);
    if (!ok) {
        return def;
    }
    return ret;
}

double ConfigurationHelper::getDouble( ConfigurationParameters& params, QString paramPath, double def ) {
    QString str = params.getValue(paramPath);
    if ( str.isEmpty() ) return def;
    bool ok;
    double ret = str.toDouble(&ok);
    if (!ok) {
        return def;
    }
    return ret;
}

bool ConfigurationHelper::getBool( ConfigurationParameters& params, QString paramPath, bool def ) {
    QString str = params.getValue(paramPath).toLower();
    if ((str == "t") || (str == "true") || (str == "1")) {
        return true;
    }
    if ((str == "f") || (str == "false") || (str == "0")) {
        return false;
    }
    // conversion failed
    return def;
}

QString ConfigurationHelper::getString( ConfigurationParameters& params, QString paramPath, QString def ) {
    QString str = params.getValue(paramPath);
    if ( str.isEmpty() ) {
        return def;
    }
    return str;
}

QStringList ConfigurationHelper::getStringList( ConfigurationParameters& params, QString paramPath, QString delimiter ) {
    return params.getValue(paramPath).split( delimiter, QString::SkipEmptyParts );
}

QVector<double> ConfigurationHelper::getVector( ConfigurationParameters& params, QString paramPath, QString def ) {
    // param will be treated as a vector, that is a list of space-separated values
    const QString paramValue = params.getValue(paramPath);
    QString str = paramValue.isEmpty() ? def : paramValue;
    QVector<double> ret;
    if ( str.isEmpty() ) return ret;
    // split the string and convert the element into double
    QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
    for( int i=0; i<list.size(); i++ ) {
        // if toDouble will fail a 0.0 will be added
        ret << list[i].toDouble();
    }
    return ret;
}

QVector<int> ConfigurationHelper::getIntegerVector(ConfigurationParameters& params, QString paramPath, QString def) {
    QVector<int> vector;
    const QString paramValue = params.getValue(paramPath);
    const QString stringVector = paramValue.isEmpty() ? def : paramValue;

    if (stringVector.isEmpty()) {
        return vector;
    }

    // Split the string and convert the element into integers
    QStringList list = stringVector.split(QRegExp("\\s+"), QString::SkipEmptyParts);
    for (int i = 0; i < list.size(); i++) {
        // If toInt fails, a 0 will be added
        vector << list[i].toInt();
    }

    return vector;
}

QVector<unsigned int> ConfigurationHelper::getUnsignedIntegerVector(ConfigurationParameters& params, QString paramPath, QString def) {
    QVector<unsigned int> vector;
    const QString paramValue = params.getValue(paramPath);
    const QString stringVector = paramValue.isEmpty() ? def : paramValue;

    if (stringVector.isEmpty()) {
        return vector;
    }

    // Split the string and convert the element into integers
    QStringList list = stringVector.split(QRegExp("\\s+"), QString::SkipEmptyParts);
    for (int i = 0; i < list.size(); i++) {
        // If toUInt fails, a 0 will be added
        vector << list[i].toUInt();
    }

    return vector;
}

QVector<bool> ConfigurationHelper::getBoolVector(ConfigurationParameters& params, QString paramPath, QString def) {
    QVector<bool> vector;
    const QString paramValue = params.getValue(paramPath);
    const QString stringVector = paramValue.isEmpty() ? def : paramValue;

    for (int i = 0; i < stringVector.size(); i++) {
        if (stringVector[i] == '0') {
            vector.append(false);
        } else if (stringVector[i] == '1') {
            vector.append(true);
        } else {
            return QVector<bool>();
        }
    }

    return vector;
}

bool ConfigurationHelper::orderByNumberAfterColon(const QString& s1, const QString& s2) {
    // If a string doesn't contain any colon, it always follows the other string; this way strings without colons are always
    // at the end when sorting
    QStringList list = s1.split(':', QString::SkipEmptyParts);
    if (list.size() < 2) {
        return false;
    }
    const double ns1 = list[1].toDouble();
    list = s2.split(':', QString::SkipEmptyParts);
    if (list.size() < 2) {
        return true;
    }
    const double ns2 = list[1].toDouble();

    return (ns1 < ns2);
}

bool ConfigurationHelper::hasGroup( ConfigurationParameters& params, QString group ) {
    //--- extract the group name
    QString groupName = group.section( '/', -1 );
    //--- extract the path
    QString groupPath = group.section( '/', 0, -2 );
    foreach( QString agroup, params.getGroupsList( groupPath ) ) {
        if ( groupName.compare( agroup, (params.isCaseSensitive() ? Qt::CaseSensitive : Qt::CaseInsensitive) ) == 0 ) {
            return true;
        }
    }
    return false;
}

bool ConfigurationHelper::hasParameter( ConfigurationParameters& params, QString group, QString paramName ) {
    return !( params.getValue( group+"/"+paramName ).isEmpty() );
}

void ConfigurationHelper::throwUserConfigError(QString paramName, QString paramValue, QString description)
{
    throw UserDefinedCheckFailureException(paramName.toLatin1().data(), paramValue.toLatin1().data(), description.toLatin1().data());
}

void ConfigurationHelper::throwUserMissingResourceError(QString resourceName, QString description)
{
    throw UserRequiredResourceMissingException(resourceName.toLatin1().data(), description.toLatin1().data());
}

QStringList ConfigurationHelper::getDescribedParameterNames( QString type, QString prefix ) {
    return Factory::getTypeDescriptions().getGroupsList(
                ParameterSettable::fullSubgroupDescriptionPath(type, prefix)+"/Parameters" );
}

QStringList ConfigurationHelper::getDescribedSubgroupNames( QString type, QString prefix ) {
    return Factory::getTypeDescriptions().getGroupsList(
                ParameterSettable::fullSubgroupDescriptionPath(type, prefix)+"/Subgroups" );
}

QString ConfigurationHelper::getParameterTypeName( QString type, QString paramName ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    return ConfigurationHelper::getString( typeDescr,
                                    ParameterSettable::fullParameterDescriptionPath( type, paramName )+"/type",
                                    "missing" );
}

bool ConfigurationHelper::isRuntimeParameter( QString type, QString paramName ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    return ConfigurationHelper::getBool( typeDescr,
                                    ParameterSettable::fullParameterDescriptionPath( type, paramName )+"/isRuntime",
                                    false );
}

bool ConfigurationHelper::parameterIsDouble( QString type, QString paramName ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    QString precision = ConfigurationHelper::getString( typeDescr,
                                            ParameterSettable::fullParameterDescriptionPath( type, paramName )+"/precision",
                                            "float" );
    return (precision == "double");
}

QStringList ConfigurationHelper::getParameterEnumValues( QString type, QString paramName ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    QStringList values = ConfigurationHelper::getStringList( typeDescr,
                                        ParameterSettable::fullParameterDescriptionPath( type, paramName )+"/values",
                                        QString(' ') );
    return values;
}

} // end namespace farsa