configuration/src/parametersettable.cpp

/***************************************************************************
 *   Copyright (C) 2008-2011 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 "parametersettable.h"
#include "factory.h"
#include "configurationparameters.h"
#include "configurationhelper.h"

// helper function for setting the properties of a parameter or a type
void setProperties( farsa::ConfigurationParameters& typeDescr, QString group, farsa::ParameterSettable::Properties props ) {
    if ( props.testFlag( farsa::ParameterSettable::IsList ) ) {
        typeDescr.createParameter( group, "isList", "true" );
    } else {
        typeDescr.createParameter( group, "isList", "false" );
    }
    if ( props.testFlag( farsa::ParameterSettable::IsMandatory ) ) {
        typeDescr.createParameter( group, "isMandatory", "true" );
    } else {
        typeDescr.createParameter( group, "isMandatory", "false" );
    }
    if ( props.testFlag( farsa::ParameterSettable::AllowMultiple ) ) {
        typeDescr.createParameter( group, "allowMultiple", "true" );
    } else {
        typeDescr.createParameter( group, "allowMultiple", "false" );
    }
};

//helper function for creating the full path to a parameter
QString fullParameterPath( QString type, QString param, QString parent ) {
    QString ret = type + "/";
    if ( parent != "" ) {
        QStringList groups = parent.split( "/", QString::SkipEmptyParts );
        foreach( QString parent, groups ) {
            ret += "Subgroups/"+parent+"/";
        }
    }
    ret += "Parameters/"+param;
    return ret;
}

//helper function for creating the full path to a subgroup
QString fullSubgroupPath( QString type, QString sub, QString parent ) {
    QString ret = type + "/";
    if ( parent != "" ) {
        QStringList groups = parent.split( "/", QString::SkipEmptyParts );
        foreach( QString parent, groups ) {
            ret += "Subgroups/"+parent+"/";
        }
    }
    ret += "Subgroups/"+sub;
    return ret;
}

namespace farsa {

const double ParameterSettable::Infinity = std::numeric_limits<double>::infinity();
const int ParameterSettable::MaxInteger = std::numeric_limits<int>::max();
const int ParameterSettable::MinInteger = std::numeric_limits<int>::min();

void ParameterSettable::setRuntimeParameter( QString paramFullPath, int newvalue ) {
    if ( !runtimeParameters.contains( paramFullPath ) ) {
        throw NoRuntimeModifiableParameter( paramFullPath.toAscii().data() );
        return;
    }
    RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
    rparam->set( newvalue );
}

void ParameterSettable::setRuntimeParameter( QString paramFullPath, unsigned int newvalue ) {
    if ( !runtimeParameters.contains( paramFullPath ) ) {
        throw NoRuntimeModifiableParameter( paramFullPath.toAscii().data() );
        return;
    }
    RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
    rparam->set( newvalue );
}

void ParameterSettable::setRuntimeParameter( QString paramFullPath, double newvalue ) {
    if ( !runtimeParameters.contains( paramFullPath ) ) {
        throw NoRuntimeModifiableParameter( paramFullPath.toAscii().data() );
        return;
    }
    RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
    rparam->set( newvalue );
}

void ParameterSettable::setRuntimeParameter( QString paramFullPath, float newvalue ) {
    if ( !runtimeParameters.contains( paramFullPath ) ) {
        throw NoRuntimeModifiableParameter( paramFullPath.toAscii().data() );
        return;
    }
    RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
    rparam->set( newvalue );
}

void ParameterSettable::setRuntimeParameter( QString paramFullPath, bool newvalue ) {
    if ( !runtimeParameters.contains( paramFullPath ) ) {
        throw NoRuntimeModifiableParameter( paramFullPath.toAscii().data() );
        return;
    }
    RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
    rparam->set( newvalue );
}

QList<RuntimeParameterSetter*> ParameterSettable::runtimeParameterList() {
    return runtimeParameters.values();
}

void ParameterSettable::markParameterAsRuntime( QString paramName, int* pointer ) {
    markParameterAsRuntime( new PointerSetter<int>( pointer, paramName ) );
}

void ParameterSettable::markParameterAsRuntime( QString paramName, double* pointer ) {
    markParameterAsRuntime( new PointerSetter<double>( pointer, paramName ) );
}

void ParameterSettable::markParameterAsRuntime( QString paramName, bool* pointer ) {
    markParameterAsRuntime( new PointerSetter<bool>( pointer, paramName ) );
}

void ParameterSettable::markParameterAsRuntime( RuntimeParameterSetter* setter ) {
    QString name = setter->getName();
    runtimeParameters[name] = setter;
}

ParameterSettable::Descriptor ParameterSettable::addTypeDescription( QString type, QString shortHelp, QString longHelp ) {
    return Descriptor( type, shortHelp, longHelp );
}

ParameterSettable::Descriptor::Descriptor( QString type, QString shortHelp, QString longHelp ) {
    this->type = type;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( type );
    typeDescr.createParameter( type, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( type, "longHelp", longHelp );
    }
}

ParameterSettable::StringDescriptor ParameterSettable::Descriptor::describeString( QString parameter ) {
    return StringDescriptor( type + "/Parameters/" + parameter );
}

ParameterSettable::IntDescriptor ParameterSettable::Descriptor::describeInt( QString parameter ) {
    return IntDescriptor( type + "/Parameters/" + parameter );
}

ParameterSettable::RealDescriptor ParameterSettable::Descriptor::describeReal( QString parameter ) {
    return RealDescriptor( type + "/Parameters/" + parameter );
}

ParameterSettable::BoolDescriptor ParameterSettable::Descriptor::describeBool( QString parameter ) {
    return BoolDescriptor( type + "/Parameters/" + parameter );
}

ParameterSettable::EnumDescriptor ParameterSettable::Descriptor::describeEnum( QString parameter ) {
    return EnumDescriptor( type + "/Parameters/" + parameter );
}

ParameterSettable::ObjectDescriptor ParameterSettable::Descriptor::describeObject( QString parameter ) {
    return ObjectDescriptor( type + "/Parameters/" + parameter );
}

ParameterSettable::SubgroupDescriptor ParameterSettable::Descriptor::describeSubgroup( QString subgroup ) {
    return SubgroupDescriptor( type + "/Subgroups/" + subgroup );
}

ParameterSettable::StringDescriptor::StringDescriptor( QString paramPath ) {
    this->paramPath = paramPath;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( paramPath );
    typeDescr.createParameter( paramPath, "type", "string" );
}

ParameterSettable::StringDescriptor& ParameterSettable::StringDescriptor::def( QString defaultValue ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "default", defaultValue );
    return (*this);
}

ParameterSettable::StringDescriptor& ParameterSettable::StringDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), paramPath, properties );
    return (*this);
}

ParameterSettable::StringDescriptor& ParameterSettable::StringDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( paramPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( paramPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::IntDescriptor::IntDescriptor( QString paramPath ) {
    this->paramPath = paramPath;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( paramPath );
    typeDescr.createParameter( paramPath, "type", "int" );
}

ParameterSettable::IntDescriptor& ParameterSettable::IntDescriptor::def( int defaultValue ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "default", QString::number(defaultValue) );
    return (*this);
}

ParameterSettable::IntDescriptor& ParameterSettable::IntDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), paramPath, properties );
    return (*this);
}

ParameterSettable::IntDescriptor& ParameterSettable::IntDescriptor::limits( int lower_bound, int upper_bound ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    if ( lower_bound != MinInteger ) {
        typeDescr.createParameter( paramPath, "lowerBound", QString::number(lower_bound) );
    }
    if ( upper_bound != MaxInteger ) {
        typeDescr.createParameter( paramPath, "upperBound", QString::number(upper_bound) );
    }
    return (*this);
}

ParameterSettable::IntDescriptor& ParameterSettable::IntDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( paramPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( paramPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::RealDescriptor::RealDescriptor( QString paramPath ) {
    this->paramPath = paramPath;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( paramPath );
    typeDescr.createParameter( paramPath, "type", "real" );
}

ParameterSettable::RealDescriptor& ParameterSettable::RealDescriptor::def( double defaultValue ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "default", QString::number(defaultValue) );
    return (*this);
}

ParameterSettable::RealDescriptor& ParameterSettable::RealDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), paramPath, properties );
    return (*this);
}

ParameterSettable::RealDescriptor& ParameterSettable::RealDescriptor::limits( double lower_bound, double upper_bound ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    if ( lower_bound != -Infinity ) {
        typeDescr.createParameter( paramPath, "lowerBound", QString::number(lower_bound) );
    }
    if ( upper_bound != +Infinity ) {
        typeDescr.createParameter( paramPath, "upperBound", QString::number(upper_bound) );
    }
    return (*this);
}

ParameterSettable::RealDescriptor& ParameterSettable::RealDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( paramPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( paramPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::BoolDescriptor::BoolDescriptor( QString paramPath ) {
    this->paramPath = paramPath;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( paramPath );
    typeDescr.createParameter( paramPath, "type", "bool" );
}

ParameterSettable::BoolDescriptor& ParameterSettable::BoolDescriptor::def( bool defaultValue ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "default", (defaultValue ? "true" : "false") );
    return (*this);
}

ParameterSettable::BoolDescriptor& ParameterSettable::BoolDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), paramPath, properties );
    return (*this);
}

ParameterSettable::BoolDescriptor& ParameterSettable::BoolDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( paramPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( paramPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::EnumDescriptor::EnumDescriptor( QString paramPath ) {
    this->paramPath = paramPath;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( paramPath );
    typeDescr.createParameter( paramPath, "type", "enum" );
}

ParameterSettable::EnumDescriptor& ParameterSettable::EnumDescriptor::def( QString defaultValue ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "default", defaultValue );
    return (*this);
}

ParameterSettable::EnumDescriptor& ParameterSettable::EnumDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), paramPath, properties );
    return (*this);
}

ParameterSettable::EnumDescriptor& ParameterSettable::EnumDescriptor::values( QStringList allValues ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "values", allValues.join(" ") );
    return (*this);
}

ParameterSettable::EnumDescriptor& ParameterSettable::EnumDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( paramPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( paramPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::ObjectDescriptor::ObjectDescriptor( QString paramPath ) {
    this->paramPath = paramPath;
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createGroup( paramPath );
    typeDescr.createParameter( paramPath, "type", "object" );
}

ParameterSettable::ObjectDescriptor& ParameterSettable::ObjectDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), paramPath, properties );
    return (*this);
}

ParameterSettable::ObjectDescriptor& ParameterSettable::ObjectDescriptor::type( QString className ) {
    Factory::getTypeDescriptions().createParameter( paramPath, "class", className );
    return (*this);
}

ParameterSettable::ObjectDescriptor& ParameterSettable::ObjectDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( paramPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( paramPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::SubgroupDescriptor::SubgroupDescriptor( QString subgroupPath ) {
    this->subgroupPath = subgroupPath;
    Factory::getTypeDescriptions().createGroup( subgroupPath );
}

ParameterSettable::SubgroupDescriptor& ParameterSettable::SubgroupDescriptor::props( Properties properties ) {
    setProperties( Factory::getTypeDescriptions(), subgroupPath, properties );
    return (*this);
}

ParameterSettable::SubgroupDescriptor& ParameterSettable::SubgroupDescriptor::type( QString className ) {
    Factory::getTypeDescriptions().createParameter( subgroupPath, "type", "object" );
    Factory::getTypeDescriptions().createParameter( subgroupPath, "class", className );
    return (*this);
}

ParameterSettable::SubgroupDescriptor& ParameterSettable::SubgroupDescriptor::help( QString shortHelp, QString longHelp ) {
    ConfigurationParameters& typeDescr = Factory::getTypeDescriptions();
    typeDescr.createParameter( subgroupPath, "shortHelp", shortHelp );
    if ( longHelp != "" ) {
        typeDescr.createParameter( subgroupPath, "longHelp", longHelp );
    }
    return (*this);
}

ParameterSettable::StringDescriptor ParameterSettable::SubgroupDescriptor::describeString( QString parameter ) {
    return StringDescriptor( subgroupPath + "/Parameters/" + parameter );
}

ParameterSettable::IntDescriptor ParameterSettable::SubgroupDescriptor::describeInt( QString parameter ) {
    return IntDescriptor( subgroupPath + "/Parameters/" + parameter );
}

ParameterSettable::RealDescriptor ParameterSettable::SubgroupDescriptor::describeReal( QString parameter ) {
    return RealDescriptor( subgroupPath + "/Parameters/" + parameter );
}

ParameterSettable::BoolDescriptor ParameterSettable::SubgroupDescriptor::describeBool( QString parameter ) {
    return BoolDescriptor( subgroupPath + "/Parameters/" + parameter );
}

ParameterSettable::EnumDescriptor ParameterSettable::SubgroupDescriptor::describeEnum( QString parameter ) {
    return EnumDescriptor( subgroupPath + "/Parameters/" + parameter );
}

ParameterSettable::ObjectDescriptor ParameterSettable::SubgroupDescriptor::describeObject( QString parameter ) {
    return ObjectDescriptor( subgroupPath + "/Parameters/" + parameter );
}

ParameterSettable::SubgroupDescriptor ParameterSettable::SubgroupDescriptor::describeSubgroup( QString subgroup ) {
    return SubgroupDescriptor( subgroupPath + "/Subgroups/" + subgroup );
}

} // end namespace farsa