options_list.hpp

Go to the documentation of this file.

/*
 *    This file is part of ACADO Toolkit.
 *
 *    ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
 *    Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
 *    Milan Vukov, Rien Quirynen, KU Leuven.
 *    Developed within the Optimization in Engineering Center (OPTEC)
 *    under supervision of Moritz Diehl. All rights reserved.
 *
 *    ACADO Toolkit is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    ACADO Toolkit 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
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with ACADO Toolkit; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#ifndef ACADO_TOOLKIT_OPTIONS_LIST_HPP
#define ACADO_TOOLKIT_OPTIONS_LIST_HPP

#include <acado/utils/acado_utils.hpp>

#include <map>
#include <memory>

BEGIN_NAMESPACE_ACADO

enum OptionsItemType
{
        OIT_UNKNOWN     = -1,   
        OIT_INT,                        
        OIT_DOUBLE,                     
        OIT_STRING                      
};

class OptionsList
{
        //
        // PUBLIC MEMBER FUNCTIONS:
        //
        public:



                OptionsList( );

                OptionsList(    const OptionsList& rhs
                                                );

                ~OptionsList( );

                OptionsList& operator=( const OptionsList& rhs
                                                                );

                template< typename T >
                inline returnValue add( OptionsName name,
                                                                const T& value );

                template< typename T >
                inline returnValue get( OptionsName name,
                                                                T& value
                                                                ) const;

                template< typename T >
                inline returnValue set( OptionsName name,
                                                                const T& value
                                                                );

                inline uint getNumber( ) const;


                inline BooleanType hasOption(   OptionsName name,
                                                                                OptionsItemType type
                                                                                ) const;


                inline BooleanType haveOptionsChanged( ) const;

                inline returnValue declareOptionsUnchanged( );


                returnValue printOptionsList( ) const;

    //
    // DATA MEMBERS:
    //
        private:

                BooleanType optionsHaveChanged;

                struct OptionValueBase
                {
                        virtual void print( std::ostream& stream ) = 0;
                };

                template< typename T >
                struct OptionValue : public OptionValueBase
                {
                        OptionValue( const T& _value )
                                : value( _value )
                        {}

                        virtual void print( std::ostream& stream )
                        {
                                stream << value;
                        }

                        T value;
                };

                typedef std::map<std::pair<OptionsName, OptionsItemType>, std::shared_ptr< OptionValueBase > > OptionItems;
                OptionItems items;
                template< typename T >
                inline OptionsItemType getType() const;
};

template< typename T >
inline OptionsItemType OptionsList::getType() const
{ return OIT_UNKNOWN; }

template<>
inline OptionsItemType OptionsList::getType< int >() const
{ return OIT_INT; }

template<>
inline OptionsItemType OptionsList::getType< double >() const
{ return OIT_DOUBLE; }

template<>
inline OptionsItemType OptionsList::getType< std::string >() const
{ return OIT_STRING; }

template< typename T >
inline returnValue OptionsList::add(    OptionsName name,
                                                                                const T& value
                                                                                )
{
        if (getType< T >() == OIT_UNKNOWN)
                return ACADOERROR( RET_NOT_IMPLEMENTED_YET );

        items[ std::make_pair(name, getType< T >()) ] =
                        std::shared_ptr< OptionValue< T > > (new OptionValue< T >( value ));

        return SUCCESSFUL_RETURN;
}

template< typename T >
inline returnValue OptionsList::get(    OptionsName name,
                                                                                T& value
                                                                                ) const
{
        if (getType< T >() == OIT_UNKNOWN)
                return ACADOERROR( RET_NOT_IMPLEMENTED_YET );

        OptionItems::const_iterator it = items.find(std::make_pair(name, getType< T >()));
        if (it != items.end())
        {
                std::shared_ptr< OptionValue< T > > ptr;
                ptr = std::static_pointer_cast< OptionValue< T > >(it->second);
                value = ptr->value;
                return SUCCESSFUL_RETURN;
        }

        return ACADOERROR( RET_OPTION_DOESNT_EXIST );
}

template< typename T >
inline returnValue OptionsList::set(    OptionsName name,
                                                                                const T& value
                                                                                )
{
        if (getType< T >() == OIT_UNKNOWN)
                return ACADOERROR( RET_NOT_IMPLEMENTED_YET );

        OptionItems::const_iterator it = items.find(std::make_pair(name, getType< T >()));
        if (it != items.end())
        {
                items[ std::make_pair(name, getType< T >()) ] =
                                std::shared_ptr< OptionValue< T > > (new OptionValue< T >( value ));

                optionsHaveChanged = BT_TRUE;

                return SUCCESSFUL_RETURN;
        }

        return ACADOERROR( RET_OPTION_DOESNT_EXIST );
}

CLOSE_NAMESPACE_ACADO

#include <acado/user_interaction/options_list.ipp>

#endif  // ACADO_TOOLKIT_OPTIONS_LIST_HPP

/*
 *      end of file
 */