parametersettable.h

/********************************************************************************
 *  FARSA - Total99                                                             *
 *  Copyright (C) 2008-2011 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef PARAMETER_SETTABLE_H
#define PARAMETER_SETTABLE_H

#include "configurationconfig.h"
#include "configurationexceptions.h"
#include "runtimeparametersetters.h"
#include <QFlags>
#include <cmath>
#include <limits>

namespace farsa {

class ConfigurationHelper;
class ConfigurationParameters;
class RealFactory;
class ParameterSettableUI;

class FARSA_CONF_API ParameterSettable
{
public:
    enum Property {
        Default = 0x0000,
        IsList = 0x0001,
        IsMandatory = 0x0002,
        AllowMultiple = 0x0004
    };
    Q_DECLARE_FLAGS( Properties, Property )
    
    
    static const double Infinity;
    static const int MaxInteger;
    static const int MinInteger;

    ParameterSettable();

    virtual ~ParameterSettable();

    virtual void save(ConfigurationParameters& params, QString prefix) = 0;
    
//#ifdef DOXYGEN_RUNNING
    static void describe( QString type ) { addTypeDescription( type, "Describe is missing" ); };
//#endif
    virtual void postConfigureInitialization()
    {
    }
    
    virtual ParameterSettableUI* getUIManager() { return NULL; };

    template<class T>
    void setRuntimeParameter( QString paramName, T newvalue ) {
        QString paramFullPath = fullParameterDescriptionPath( type, paramName );
        if ( !runtimeParameters.contains( paramFullPath ) ) {
            throw NoRuntimeModifiableParameter( paramFullPath.toLatin1().data() );
        }
        RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
        rparam->set( this, newvalue );
        foreach( RuntimeParameterObserver* obs, observers ) {
            obs->onParameterChanges( this, paramName );
        }
    };
    template<class T>
    T getRuntimeParameter( QString paramName ) {
        QString paramFullPath = fullParameterDescriptionPath( type, paramName );
        if ( !runtimeParameters.contains( paramFullPath ) ) {
            throw NoRuntimeModifiableParameter( paramFullPath.toLatin1().data() );
        }
        RuntimeParameterSetter* rparam = runtimeParameters[paramFullPath];
        T ret;
        rparam->get( this, ret );
        return ret;
    };
    
    void addObserver( RuntimeParameterObserver* obs );
    
    void removeObserver( RuntimeParameterObserver* obs );
    
    QString typeName() const {
        return type;
    };

    static QString fullParameterDescriptionPath( QString type, QString param );
    static QString fullSubgroupDescriptionPath( QString type, QString sub );

protected:
    void notifyChangesToParam( QString paramName );

    class FARSA_CONF_API StringDescriptor {
    public:
        StringDescriptor( QString paramPath );
        StringDescriptor& def( QString defaultValue );
        StringDescriptor& props( Properties properties );
        template<class T>
        StringDescriptor& runtime( void (T::*setter)(QString), QString (T::*getter)()const ) {
            ParameterSettable::createParamDescription( paramPath, "isRuntime", "true" );
            ParameterSettable::runtimeParameters[paramPath] = new MethodSetter<T, QString>( paramPath, setter, getter );
            return (*this);
        };
        StringDescriptor& help( QString shortHelp, QString longHelp=QString("") );
    private:
        QString paramPath;
    };

    class FARSA_CONF_API IntDescriptor {
    public:
        IntDescriptor( QString paramPath );
        IntDescriptor& def( int defaultValue );
        IntDescriptor& props( Properties properties );
        IntDescriptor& limits( int lower_bound, int upper_bound );
        template<class T>
        IntDescriptor& runtime( void (T::*setter)(int), int (T::*getter)()const ) {
            ParameterSettable::createParamDescription( paramPath, "isRuntime", "true" );
            ParameterSettable::runtimeParameters[paramPath] = new MethodSetter<T, int>( paramPath, setter, getter );
            return (*this);
        };
        IntDescriptor& help( QString shortHelp, QString longHelp=QString("") );
    private:
        QString paramPath;
    };

    class FARSA_CONF_API RealDescriptor {
    public:
        RealDescriptor( QString paramPath );
        RealDescriptor& def( double defaultValue );
        RealDescriptor& props( Properties properties );
        RealDescriptor& limits( double lower_bound, double upper_bound );
        template<class T>
        RealDescriptor& runtime( void (T::*setter)(double), double (T::*getter)()const ) {
            ParameterSettable::createParamDescription( paramPath, "isRuntime", "true" );
            ParameterSettable::createParamDescription( paramPath, "precision", "double" );
            ParameterSettable::runtimeParameters[paramPath] = new MethodSetter<T, double>( paramPath, setter, getter );
            return (*this);
        };
        template<class T>
        RealDescriptor& runtime( void (T::*setter)(float), float (T::*getter)()const ) {
            ParameterSettable::createParamDescription( paramPath, "isRuntime", "true" );
            ParameterSettable::createParamDescription( paramPath, "precision", "float" );
            ParameterSettable::runtimeParameters[paramPath] = new MethodSetter<T, float>( paramPath, setter, getter );
            return (*this);
        };
        RealDescriptor& help( QString shortHelp, QString longHelp=QString("") );
    private:
        QString paramPath;
    };

    class FARSA_CONF_API BoolDescriptor {
    public:
        BoolDescriptor( QString paramPath );
        BoolDescriptor& def( bool defaultValue );
        BoolDescriptor& props( Properties properties );
        template<class T>
        BoolDescriptor& runtime( void (T::*setter)(bool), bool (T::*getter)()const ) {
            ParameterSettable::createParamDescription( paramPath, "isRuntime", "true" );
            ParameterSettable::runtimeParameters[paramPath] = new MethodSetter<T, bool>( paramPath, setter, getter );
            return (*this);
        };
        BoolDescriptor& help( QString shortHelp, QString longHelp=QString("") );
    private:
        QString paramPath;
    };

    class FARSA_CONF_API EnumDescriptor {
    public:
        EnumDescriptor( QString paramPath );
        EnumDescriptor& def( QString defaultValue );
        EnumDescriptor& props( Properties properties );
        EnumDescriptor& values( QStringList allValues );
        template<class T>
        EnumDescriptor& runtime( void (T::*setter)(unsigned int), unsigned int (T::*getter)()const ) {
            ParameterSettable::createParamDescription( paramPath, "isRuntime", "true" );
            ParameterSettable::runtimeParameters[paramPath] = new MethodSetter<T, unsigned int>( paramPath, setter, getter );
            return (*this);
        };
        EnumDescriptor& help( QString shortHelp, QString longHelp=QString("") );
    private:
        QString paramPath;
    };

    class FARSA_CONF_API ObjectDescriptor {
    public:
        ObjectDescriptor( QString paramPath );
        ObjectDescriptor& props( Properties properties );
        ObjectDescriptor& type( QString className );
        ObjectDescriptor& help( QString shortHelp, QString longHelp=QString("") );
    private:
        QString paramPath;
    };

    class FARSA_CONF_API SubgroupDescriptor {
    public:
        SubgroupDescriptor( QString paramPath );
        SubgroupDescriptor& props( Properties properties );
        SubgroupDescriptor& type( QString className );
        SubgroupDescriptor& help( QString shortHelp, QString longHelp=QString("") );
        StringDescriptor describeString( QString parameter );
        IntDescriptor describeInt( QString parameter );
        RealDescriptor describeReal( QString parameter );
        BoolDescriptor describeBool( QString parameter );
        EnumDescriptor describeEnum( QString parameter );
        ObjectDescriptor describeObject( QString parameter );
        SubgroupDescriptor describeSubgroup( QString subgroup );
    private:
        QString subgroupPath;
    };

    class FARSA_CONF_API Descriptor {
    public:
        Descriptor( QString type, QString shortHelp, QString longHelp );
        StringDescriptor describeString( QString parameter );
        IntDescriptor describeInt( QString parameter );
        RealDescriptor describeReal( QString parameter );
        BoolDescriptor describeBool( QString parameter );
        EnumDescriptor describeEnum( QString parameter );
        ObjectDescriptor describeObject( QString parameter );
        SubgroupDescriptor describeSubgroup( QString subgroup );
    private:
        QString type;
    };

    static Descriptor addTypeDescription( QString type, QString shortHelp, QString longHelp=QString("") );

    template <class EditorType>
    static void setGraphicalEditor( QString type );

private:
    // this friend allow to correctly set the typeName of a ParameterSettable only by the RealFactory
    friend class RealFactory;
    QString type;
    void setTypeName( QString type ) {
        this->type = type;
    };
    QList<RuntimeParameterObserver*> observers;
    static QMap<QString, RuntimeParameterSetter*> runtimeParameters;
    static void createParamDescription( QString paramPath, QString traitName, QString traitValue );
};

class FARSA_CONF_TEMPLATE ParameterSettableInConstructor : public ParameterSettable
{
public:
    ParameterSettableInConstructor()
    {
    }

    ParameterSettableInConstructor(ConfigurationParameters& /*params*/, QString /*prefix*/)
    {
    }

    virtual ~ParameterSettableInConstructor()
    {
    }
};

class FARSA_CONF_TEMPLATE ParameterSettableWithConfigureFunction : public ParameterSettable
{
public:
    ParameterSettableWithConfigureFunction()
    {
    }

    virtual ~ParameterSettableWithConfigureFunction()
    {
    }

    virtual void configure(ConfigurationParameters& params, QString prefix) = 0;
};

} // end namespace farsa

Q_DECLARE_OPERATORS_FOR_FLAGS( farsa::ParameterSettable::Properties )

// Implementation of template functions
// #include "factory.h"
// 
// namespace farsa {
// 
//  template <class EditorType>
//  void ParameterSettable::setGraphicalEditor( QString type )
//  {
//      Factory::registerEditorForType<EditorType>(type);
//  }
// 
// }

#endif