param_utils.h

/*
 * This file is part of SPORE.
 *
 * Copyright (C) 2016, the SPORE team (see AUTHORS).
 *
 * SPORE 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.
 *
 * SPORE 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 SPORE.  If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information see: https://github.com/IGITUGraz/spore-nest-module
 *
 * File:   param_utils.h
 * Author: kappel
 *
 * Created on March 31, 2017, 6:10 PM
 */

#ifndef PARAM_UTILS_H
#define PARAM_UTILS_H

#include <string>
#include <sstream>
#include <exception>

#include "nest.h"
#include "kernel_manager.h"
#include "exceptions.h"
#include "dictdatum.h"
#include "logging.h"


namespace spore
{

namespace pc
{
template < typename T >
    class Con
{
public:
    virtual void apply( T const&, const Name& name ) const = 0;
};

template < typename T >
    class CMin : public Con < T >
{
public:
    CMin( T min_value )
    : min_value_( min_value )
    {
    }

    void apply( T const& val, const Name& name ) const
    {
        if ( val < min_value_ )
        {
            std::stringstream strm;
            strm << "Parameter '" << name << "' must not be smaller than " << T(min_value_) << " but is " << T(val);
            LOG( nest::M_ERROR, "CMin::apply()", strm.str() );
            throw nest::BadProperty("Parameter out of range. See LOG file for details.");
        }
    }

private:
    T min_value_;
};

template < typename T >
    class CMax : public Con < T >
{
public:
    CMax( T max_value )
    : max_value_( max_value )
    {
    }

    void apply( T const& val, const Name& name ) const
    {
        if ( val > max_value_ )
        {
            std::stringstream strm;
            strm << "Parameter '" << name << "' must not be bigger than " << T(max_value_) << " but is " << T(val);
            LOG( nest::M_ERROR, "CMax::apply()", strm.str() );
            throw nest::BadProperty("Parameter out of range. See LOG file for details.");
        }
    }

private:
    T max_value_;
};

template < typename T >
    class CBigger : public Con < T >
{
public:
    CBigger( T min_value )
    : min_value_( min_value )
    {
    }

    void apply( T const& val, const Name& name ) const
    {
        if ( val <= min_value_ )
        {
            std::stringstream strm;
            strm << "Parameter '" << name << "' must be strictly bigger than " << T(min_value_) << " but is " << T(val);
            LOG( nest::M_ERROR, "CBigger::apply()", strm.str() );
            throw nest::BadProperty("Parameter out of range. See LOG file for details.");
        }
    }

private:
    T min_value_;
};

template < typename T >
    class CSmaller : public Con < T >
{
public:
    CSmaller( T min_value )
    : max_value_( min_value )
    {
    }

    void apply( T const& val, const Name& name ) const
    {
        if ( val >= max_value_ )
        {
            std::stringstream strm;
            strm << "Parameter '" << name << "' must be strictly smaller than " << T(max_value_)
                 << " but is " << T(val);
            LOG( nest::M_ERROR, "CSmaller::apply()", strm.str() );
            throw nest::BadProperty("Parameter out of range. See LOG file for details.");
        }
    }

private:
    T max_value_;
};

typedef CMin< double > MinD;
typedef CMin< long > MinL;
typedef CMin< unsigned long > MinUL;
typedef CMin< int > MinI;
typedef CMin< unsigned int > MinUI;
typedef CMax< double > MaxD;
typedef CMax< long > MaxL;
typedef CMax< unsigned long > MaxUL;
typedef CMax< int > MaxI;
typedef CMax< unsigned int > MaxUI;
typedef CBigger< double > BiggerD;
typedef CBigger< long > BiggerL;
typedef CBigger< unsigned long > BiggerUL;
typedef CBigger< int > BiggerI;
typedef CBigger< unsigned int > BiggerUI;
typedef CSmaller< double > SmallerD;
typedef CSmaller< long > SmallerL;
typedef CSmaller< unsigned long > SmallerUL;
typedef CSmaller< int > SmallerI;
typedef CSmaller< unsigned int > SmallerUI;
}

class SetDefault
{
public:
    SetDefault();

    template < typename T >
        void parameter( T& val, const Name& name, T default_val )
    {
        val = default_val;
    }

    template < typename T >
        void parameter( T& val, const Name& name, T default_val, const pc::Con< T >& con1 )
    {
        con1.apply(default_val, name);
        val = default_val;
    }

    template < typename T >
        void parameter( T& val, const Name& name, T default_val, const pc::Con< T >& con1,
                        const pc::Con< T >& con2 )
    {
        con1.apply(default_val, name);
        con2.apply(default_val, name);
        val = default_val;
    }

    template < typename T >
        void parameter( T& val, const Name& name, T default_val, const pc::Con< T >& con1,
                        const pc::Con< T >& con2, const pc::Con< T >& con3 )
    {
        con1.apply(default_val, name);
        con2.apply(default_val, name);
        con3.apply(default_val, name);
        val = default_val;
    }
};

class GetStatus
{
public:
    GetStatus(DictionaryDatum& d);

    template < typename T >
        void parameter( const T& val, const Name& name, T )
    {
        def< T >(d_, name, val);
    }

    template < typename T >
        void parameter( const T& val, const Name& name, T, const pc::Con< T >& )
    {
        def< T >(d_, name, val);
    }

    template < typename T >
        void parameter( const T& val, const Name& name, T, const pc::Con< T >&, const pc::Con< T >& )
    {
        def< T >(d_, name, val);
    }

    template < typename T >
        void parameter( const T& val, const Name& name, T, const pc::Con< T >&, const pc::Con< T >&,
                  const pc::Con< T >& )
    {
        def< T >(d_, name, val);
    }

private:
    DictionaryDatum& d_;
};

class CheckParameters
{
public:
    CheckParameters(const DictionaryDatum& d);

    template < typename T >
        void parameter( const T&, const Name&, T )
    {
    }

    template < typename T >
        void parameter( const T&, const Name& name, T, const pc::Con< T >& con1 )
    {
        T val;
        if (updateValue< T >(d_, name, val))
        {
            con1.apply(val, name);
        }
    }

    template < typename T >
        void parameter( const T&, const Name& name, T, const pc::Con< T >& con1,
                        const pc::Con< T >& con2 )
    {
        T val;
        if (updateValue< T >(d_, name, val))
        {
            con1.apply(val, name);
            con2.apply(val, name);
        }
    }

    template < typename T >
        void parameter( const T&, const Name& name, T, const pc::Con< T >& con1,
                        const pc::Con< T >& con2, const pc::Con< T >& con3 )
    {
        T val;
        if (updateValue< T >(d_, name, val))
        {
            con1.apply(val, name);
            con2.apply(val, name);
            con3.apply(val, name);
        }
    }

private:
    const DictionaryDatum& d_;
};

class SetStatus
{
public:
    SetStatus(const DictionaryDatum& d);

    template < typename T >
        void parameter( T& val, const Name& name, T )
    {
        updateValue< T >(d_, name, val);
    }

    template < typename T >
        void parameter( T& val, const Name& name, T, const pc::Con< T >& )
    {
        updateValue< T >(d_, name, val);
    }

    template < typename T >
        void parameter( T& val, const Name& name, T, const pc::Con< T >&, const pc::Con< T >& )
    {
        updateValue< T >(d_, name, val);
    }

    template < typename T >
        void parameter( T& val, const Name& name, T, const pc::Con< T >&, const pc::Con< T >&,
                        const pc::Con< T >& )
    {
        updateValue< T >(d_, name, val);
    }

private:
    const DictionaryDatum& d_;
};

}

#endif