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 {

class UIException : public std::exception {

public:
        const string message;

        const string path;

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

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

        virtual const char* what() const throw() {
                return ( message + " " + path ).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 sttng_xcptn ) {
                        string msg = "the method " + class_name + ".from_setting(Setting&) has thrown a SettingException. Try to correct this method. Check path \"" + sttng_xcptn.getPath() + "\".";
                        throw exception ( msg.c_str() );
                } catch ( UIException uixcptn ) {
                        string msg = "the method " + class_name + ".from_setting(Setting&) has thrown an UIException \"" + uixcptn.message + "\" Try to correct this method. Check path \"" + uixcptn.path + "\".";
                        throw exception ( msg.c_str() );
                } catch ( exception xcptn ) {
                        string msg = "the method " + class_name + ".from_setting(Setting&) has thrown a general exception \"" + xcptn.what() + "\" Try to correct this method. Check path \"" + element.getPath() + "\".";
                        throw exception ( msg.c_str() );
                }
        }

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

        template<class T> static void from_setting ( T &array_to_load, const Setting &element ) {
                throw UIException( "from_setting is not implemented for this type", element );
        }


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

public:

        enum SettingPresence { optional, compulsory } ;


        template<class T> static T* build ( const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
                if ( !element.exists ( name ) )
                {
                        if( settingPresence == optional )
                                return NULL;
                        else
                                throw UIException ( "the compulsory Setting named \"" + name + "\" is missing", element );
                }

                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, SettingPresence settingPresence = optional ) {
                if ( element.getLength() <= index )
                {
                        if( settingPresence == optional )
                                return NULL;
                        else
                        {
                                stringstream stream;
                                stream << index;
                                throw UIException ( "the compulsory Setting with the index " + stream.str()+ " is missing", element );
                        }
                }

                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 bool get ( T &instance, const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
                if ( !element.exists ( name ) )
                {
                        if( settingPresence == optional )
                                return false;
                        else
                                throw UIException ( "the compulsory Setting named \"" + name + "\" is missing", element );
                }

                from_setting ( instance, to_child_setting ( element, name ) );
                return true;
        }

        template<class T> static bool get ( T &instance, const Setting &element, const int index, SettingPresence settingPresence = optional ) {
                if ( element.getLength() <= index )
                {
                        if( settingPresence == optional )
                                return false;
                        else
                        {
                                stringstream stream;
                                stream << index;
                                throw UIException ( "the compulsory Setting with the index " + stream.str()+ " is missing", element );
                        }
                }

                from_setting ( instance, to_child_setting ( element, index ) );
                return true;
        }

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


        template<class T> static bool get ( Array<T> &array_to_load, const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
                if ( !element.exists ( name ) )
                        return false;

                from_setting ( array_to_load, to_child_setting ( element, name ) );
                return true;
        }

        template<class T> static bool get ( Array<T> &array_to_load, const Setting &element, const int index, SettingPresence settingPresence = optional ) {
                if ( element.getLength() <= index )
                        return false;

                from_setting ( array_to_load, to_child_setting ( element, index ) );
                return true;
        }

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


        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 sttng_xcptn ) {
                        string msg = "the method " + class_name + ".to_setting(Setting&) has thrown a SettingException. Try to correct this method. Check path \"" + sttng_xcptn.getPath() + "\".";
                        throw exception ( msg.c_str() );
                } catch ( UIException uixcptn ) {
                        string msg = "the method " + class_name + ".to_setting(Setting&) has thrown an UIException \"" + uixcptn.message + "\" Try to correct this method. Check path \"" + uixcptn.path + "\".";
                        throw exception ( msg.c_str() );
                } catch ( exception xcptn ) {
                        string msg = "the method " + class_name + ".to_setting(Setting&) has thrown a general exception \"" + xcptn.what() + "\" Try to correct this method. Check path \"" + element.getPath() + "\".";
                        throw exception ( msg.c_str() );
                }
        }

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

}

#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

#endif // #ifndef USER_INFO_H

---