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 "../shared_ptr.h"
#include "itpp/itbase.h"


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

namespace bdm {

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

public:
        UIException ( const string &message ) :
                message ( message ) {
        }

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

        ~UIException() throw() {};

protected:
        static string format_message( const string &reason, const string &path );
};

class UISettingException : public UIException {
public:
        UISettingException ( const string &message, const Setting &element ):
                UIException ( format_message ( message, string ( element.getPath() ) ) ) {
        }

        UISettingException ( const string &message, const string &path ):
                UIException ( format_message ( message, path ) ) {
        }

        ~UISettingException() throw() {};
};

class UIClassException : public UIException {
public:
        UIClassException ( const string &message, const Setting &element ):
                UIException ( format_message ( message, string ( element.getPath() ) ) ) {
        }

        UIClassException ( const string &message, const string &path ):
                UIException ( format_message ( message, path ) ) {
        }

        ~UIClassException() 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 UIClassException ( "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();
                bdm_assert ( typeless_instance, "UI::new_instance failed" );

                instance = dynamic_cast<T*> ( typeless_instance );
                if ( !instance ) {
                        delete typeless_instance;
                        throw UIClassException ( "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 ) {
                        delete instance;
                        instance = 0;
                        string msg = "UIException: method ";
                        msg += class_name;
                        msg += ".from_setting(Setting&) has thrown a SettingException.";
                        throw UISettingException(msg, sttng_xcptn.getPath());
                } catch (std::runtime_error &e) {
                        delete instance;
                        instance = 0;
                        string msg = "UIException: method ";
                        msg += class_name;
                        msg += " says: ";
                        msg += e.what();
                        throw UISettingException(msg, link.result);
                } catch (...) {
                        delete instance;
                        instance = 0;
                        throw;
                }
}

        template<class T>
        static void from_setting ( shared_ptr<T> &instance, const Setting &element ) {
                T *tmp_inst = 0;
                from_setting ( tmp_inst, element );
                bdm_assert ( tmp_inst, "UI::from_setting failed" );
                instance = tmp_inst;
        }

        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 &variable_to_load, const Setting &element ) {
                std::string msg = "UIException: from_setting is not implemented for type ";
                msg += typeid(T).name();
                msg += '.';
                throw UISettingException ( msg, 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 shared_ptr<T> build ( const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
                if ( !element.exists ( name ) ) {
                        if ( settingPresence == optional )
                                return shared_ptr<T>();
                        else
                                throw UISettingException ( "UIException: the compulsory Setting named \"" + name + "\" is missing.", element );
                }

                shared_ptr<T> instance;
                from_setting<T> ( instance, to_child_setting ( element, name ) );
                return instance;
        }

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

                shared_ptr<T> instance;
                from_setting<T> ( instance, to_child_setting ( element, index ) );
                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 UISettingException ( "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 << "UIException: the compulsory Setting with the index " << index << " is missing.";
                                stream << index;
                                throw UISettingException (stream.str(), 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 = "UIException: method ";
                        msg += class_name;
                        msg += ".to_setting(Setting&) has thrown a SettingException.";
                        throw UISettingException(msg, sttng_xcptn.getPath());
                }
        }

        template< class T> static void save ( const shared_ptr<T> &instance, Setting &element, const string &name = "" ) {
                save<T> ( instance.get(), element, name );
        }

        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 {
public:
        ParticularUI<T> ( const string &class_name ) : UI ( class_name, &typeid ( T ) ) {};

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

}

#ifndef BDMLIB
#define UIREGISTER(class_name) static bdm::ParticularUI<class_name> UI##class_name(#class_name)
#else
#define UIREGISTER(class_name)
#endif

#define QUOTEME(x) #x

#ifndef BDMLIB
#define UIREGISTER2(class_name, temp_name) static bdm::ParticularUI<class_name<temp_name> > UI##class_name##_##temp_name( QUOTEME(class_name<temp_name>) )
#else
#define UIREGISTER2(class_name,temp_name) 
#endif

#endif // #ifndef USER_INFO_H

---