user_info.h

#ifndef USER_INFO_H
#define USER_INFO_H

#include <stdio.h>
#include <string>
#include <typeinfo>
#include <map>

#include "libconfig/libconfig.h++"
#include "../bdmroot.h"
#include "itpp/itbase.h"

#include <stdexcept>

using std::string;
using namespace std;
using namespace libconfig;

namespace bdm
{
        
#ifndef BDMLIB 
#define UIREGISTER(class_name) template<> const ParticularUI<class_name>& ParticularUI<class_name>::ui = ParticularUI<class_name>(#class_name) 
#else
#define UIREGISTER(class_name)
#endif

#define ASSERT_UITYPE(SET,TYPE) it_assert_debug(SET.getType()==Setting::TYPE, string("Wrong setting type, see input path \"")+string(SET.getPath())+string("\""))

class UIbuildException : public std::invalid_argument {
        public:
                UIbuildException() : std::invalid_argument("class name") { }
};

class UIFile : public Config
{
public:
        UIFile();

        UIFile( const string &file_name );

        void save(const string &file_name);

        operator Setting&();
};



class UI 
{
private:
        class MappedUI
        {
        private:
                typedef map< const string, const UI* const > StringToUIMap;

                typedef map< const type_info * const, const string > TypeInfoToStringMap;

                static StringToUIMap& mapped_strings();

                static TypeInfoToStringMap& mapped_type_infos();

                static void unregistered_class_error( const string &unregistered_class_name );

        public:
                static void add_class( const string &class_name, const type_info * const class_type_info, const UI* const ui );

                static const UI& retrieve_ui( const string &class_name );

                static const string& retrieve_class_name( const type_info* const class_type_info );
        };

        virtual root* new_instance() const = 0;
        
        static const Setting& to_child_setting( const Setting &element, const int index );

        static const Setting& to_child_setting( const Setting &element, const string &name );

        static void from_setting( mat& matrix, const Setting &element );        
        static void from_setting( ivec &vector, const Setting &element );
        static void from_setting( string &str, const Setting &element );
        static void from_setting( vec &vector, const Setting &element );
        static void from_setting( int &integer, const Setting &element );
        static void from_setting( double &real, const Setting &element );
        template<class T> static void from_setting( T* &instance, const Setting &element )
        {                       
                const SettingResolver link( element );

                ASSERT_UITYPE(link.result,TypeGroup);

                // we get a velue stored in the "class" attribute 
                string class_name;
                if( !link.result.lookupValue( "class", class_name ) )
                        ui_error( "the obligatory ""class"" identifier is missing", link.result );
        
                // then we find a user-info related to this type
                const UI& related_UI = MappedUI::retrieve_ui( class_name );
                
                root* typeless_instance = related_UI.new_instance();

                instance = NULL;
                //try catch does not work!!!
                instance = dynamic_cast<T*>(typeless_instance);
                if (!instance){
                        throw UIbuildException();
                }
//              catch(...)
//              {
                        // TODO pouzit ui_error? 
//                      it_error ( "UI error: class " + class_name + " is not a descendant of the desired output class. Try to call the UI::build function with a different type parameter." );
//              }
//              
                try
                {
                        instance->from_setting( link.result );
                }
                catch(SettingException xcptn)
                {
                        // TODO pouzit ui_error? 
                        it_error ( "UI error: the method " + class_name + ".from_setting(Setting&) has thrown an exception when parsing the setting " + xcptn.getPath() + ". Try to correct this method." );
                }
        }       

        // TODO efektivne jen pro vect, mat a string, pro dalsi je nutne pridat from_setting metodu.. ale to asi necceme
        template<class T> static void from_setting( Array<T> &array_to_load, const Setting &element )
        {
                const SettingResolver link( element );

                ASSERT_UITYPE(link.result,TypeList);

                int len = link.result.getLength();
                array_to_load.set_length( len );
                if( len == 0 ) return;
                
                for( int i=0; i < len; i++ ) 
                        from_setting( array_to_load(i), link.result[i] ); 
        }

        static void ui_error( string message, const Setting &element );

protected:
        UI( const string& class_name, const type_info * const class_type_info ) 
        {       
                MappedUI::add_class( class_name, class_type_info, this );
        }

public: 

        class SettingResolver   
        {
        private:
                UIFile *file;

                const Setting &initialize_reference( UIFile* &file, const Setting &potential_link);

        public:
                const Setting &result;

                SettingResolver( const Setting &potential_link );
                
                ~SettingResolver();             
        };

        //TODO
        template<class T> static T* build( const Setting &element, const int index )
        {
                T* instance;
                from_setting<T>( instance, to_child_setting( element, index ) );
                return instance;
        }
        template<class T> static T* build( const Setting &element )
        {
                T* instance;
                from_setting<T>( instance,  element );
                return instance;
        }

        template<class T> static T* build( const Setting &element, const string &name )
        {                       
                T* instance;
                from_setting<T>( instance, to_child_setting( element, name ) );
                return instance;
        }

        template<class T> static void get( T &instance, const Setting &element, const string &name )
        {
                from_setting( instance, to_child_setting( element, name ) );
        }

        template<class T> static void get( T &instance, const Setting &element, const int index )
        {
                from_setting( instance, to_child_setting( element, index ) );
        }

        template<class T> static void get( T &instance, const Setting &element  )
        {
                from_setting( instance, element );
        }

        template<class T> static void get( Array<T> &array_to_load, const Setting &element, const string &name )
        {
                from_setting( array_to_load, to_child_setting( element, name ) );
        }

        template<class T> static void get( Array<T> &array_to_load, const Setting &element, const int index )
        {
                from_setting( array_to_load, to_child_setting( element, index ) );
        }

        template<class T> static void get( Array<T> &array_to_load, const Setting &element  )
        {
                from_setting( array_to_load, element );
        }

        template< class T> static void save( const T * const instance, Setting &element, const string &name = "")
        {
                Setting &set = (name == "") ? element.add( Setting::TypeGroup )                                                 
                                                                         : element.add( name, Setting::TypeGroup );             

                const string &class_name = MappedUI::retrieve_class_name( &typeid(*instance) );
                        
                // add attribute "class" 
                Setting &type = set.add( "class", Setting::TypeString );
                type = class_name;

                try
                {
                        instance->to_setting( set );
                }
                catch(SettingException xcptn)
                {
                        it_error ( "UI error: the method " + class_name + ".to_setting(Setting&) has thrown an exception when filling the setting " + xcptn.getPath() + ". Try to correct this method." );
                }       
        }

        template<class T> static void save( const Array<T> &array_to_save, Setting &element, const string &name = "" )
        {
                ASSERT_UITYPE(element,TypeGroup);
                Setting &list = (name == "") ? element.add( Setting::TypeList )                                                 
                                                                         : element.add( name, Setting::TypeList );              
                for( int i=0; i<array_to_save.length(); i++ ) 
                        save( array_to_save(i), list );
        }


        static void save( const mat &matrix, Setting &element, const string &name = "" );

        static void save( const ivec &vec, Setting &element, const string &name = "" );
        
        static void save( const vec &vector, Setting &element, const string &name = "" );
        static void save( const string &str, Setting &element, const string &name = "" );

        static void save( const int &integer, Setting &element, const string &name = "" );

        static void save( const double &real, Setting &element, const string &name = "" );      

};


template<typename T> class ParticularUI : private UI
{
        public:

        ParticularUI<T>( const string &class_name) : UI( class_name, &typeid(T) ) 
        {       cout << class_name << endl;
        };

        static const ParticularUI<T>& ui;       

        root* new_instance() const
        {
                return new T();
        }
};




}

#endif // #ifndef USER_INFO_H

---