user_info.h

Go to the documentation of this file.

#ifndef USER_INFO_H
#define USER_INFO_H

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

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


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>::factory = ParticularUI<class_name>(#class_name) 
#else
        #define UIREGISTER(class_name)
#endif

class UIException : public std::exception
{
private:
        const string message;

public:
        UIException( const string &message, const Setting &element  ) 
                : message( "UI error: " + message + ". Check path \"" + string(element.getPath()) + "\"." )
        {
        }

        UIException( const string &message, const string &path  ) 
                : message( "UI error: " + message + "! Check path \"" + path + "\"." )
        {
        }

        virtual const char* what() const throw()
        {
                return message.c_str();
        }
        ~UIException() throw() {};
};


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

        UIFile( const string &file_name );

        void save(const string &file_name);

        operator Setting&();
};

class SettingResolver : root
{
private:
        UIFile *file;

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

public:
        const Setting &result;

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

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

        static void assert_type( const Setting &element, Setting::Type type);

        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_type(link.result,Setting::TypeGroup);

                // we get a value stored in the "class" attribute 
                string class_name;
                if( !link.result.lookupValue( "class", class_name ) )
                        throw UIException( "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 = dynamic_cast<T*>(typeless_instance);
                if (!instance)
                        throw UIException( "class " + class_name + " is not a descendant of the desired output class. Try to call the UI::build<T> function with a different type parameter.", link.result );
                
                try
                {
                        instance->from_setting( link.result );
                }
                catch(SettingException xcptn)
                {
                        throw UIException( "the method " + class_name + ".from_setting(Setting&) has thrown an SettingException. Try to correct this method", xcptn.getPath());
                }
        }       

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

                assert_type(link.result,Setting::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] ); 
        }

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

public: 


        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 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 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)
                {
                        throw UIException( "the method " + class_name + ".to_setting(Setting&) has thrown an SettingException. Try to correct this method", xcptn.getPath());
                }       
        }

        template<class T> static void save( const Array<T> &array_to_save, Setting &element, const string &name = "" )
        {
                assert_type(element,Setting::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
{
private:
        ParticularUI<T>( const string &class_name) : UI( class_name, &typeid(T) ) 
        {};

public:
        static const ParticularUI<T>& factory;  

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

}

#endif // #ifndef USER_INFO_H

---