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" );
    }
};

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();

QMap<QString, RuntimeParameterSetter*> ParameterSettable::runtimeParameters;

ParameterSettable::ParameterSettable()
{
}

ParameterSettable::~ParameterSettable()
{
    foreach( RuntimeParameterObserver* obs, observers ) {
        obs->onObjectDestruction( this );
    }
}

void ParameterSettable::addObserver( RuntimeParameterObserver* obs ) {
    if ( !observers.contains( obs ) ) {
        observers.append( obs );
    }
}

void ParameterSettable::removeObserver( RuntimeParameterObserver* obs ) {
    observers.removeAll( obs );
}

void ParameterSettable::notifyChangesToParam( QString paramName ) {
    foreach( RuntimeParameterObserver* obs, observers ) {
        obs->onParameterChanges( this, paramName );
    }
}

QString ParameterSettable::fullParameterDescriptionPath( QString type, QString param ) {
    QString ret = type + "/";
    QStringList groups = param.split( "/", QString::SkipEmptyParts );
    for( int i=0; i<groups.size()-1; i++ ) {
        ret += "Subgroups/"+groups[i]+"/";
    }
    ret += "Parameters/"+groups.last();
    return ret;
}

QString ParameterSettable::fullSubgroupDescriptionPath( QString type, QString sub ) {
    QString ret = type + "/";
    QStringList groups = sub.split( "/", QString::SkipEmptyParts );
    foreach( QString agroup, groups ) {
        ret += "Subgroups/"+agroup+"/";
    }
    return ret;
}

void ParameterSettable::createParamDescription( QString paramPath, QString traitName, QString traitValue ) {
    Factory::getTypeDescriptions().createParameter( paramPath, traitName, traitValue );
}

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