root/bdm/user_info.h @ 345

#ifndef UIBUILD
#define UIBUILD

#include <itpp/itbase.h>
#include "stat/libBM.h"
#include "libconfig/libconfig.h++"

#include <sstream>
#include <iostream>
#include <stdio.h>
#include <string>
#include <typeinfo>
#include <map>
#include <utility>
#include <vector>
#include <iostream>

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

#define UIREGISTER(class_name) template<> Particular_UI<class_name>& Particular_UI<class_name>::ui = Particular_UI<class_name>(#class_name)

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

namespace bdm
{

/*!
@brief This class serves to load and/or save DOMElements into/from files
stored on a hard-disk.

Firstly, you associate new RootElement instance with some filename during a time of its 
construtcion. Then, you save some object into the new RootElement instance,
and save it into the file this way:
\code
        CAudi audi;
        RootElement root("cars.xml");
        UserInfo::save( audi, root, "TT");
        root.save();
\endcode

In the other way round, when loading object from a XML file, the appropriate code looks like this:
\code
        RootElement root("cars.xml");
        root.load();
        UserInfo::build<T>(root,"TT");
\endcode
*/

class UI_File : public Config
{
private:
        const string file_name;

public:
        //! attach new RootElement instance to a file (typically with an XML extension)
        UI_File( const string &file_name );

        //! loads root element from a file
        void load();

        //! save UserInfo to the file (typically with an XML extension)
        void save();

        operator Setting&();
};


/*!
@brief UserInfo is an abstract is for internal purposes only. Use CompoundUserInfo<T> or Particular_UI<T> instead.
The raison d'etre of this class is to allow pointers to its templated descendants. 

Also, the main functions of the whole UserInfo library are included within this class, see
static methods 'build' and 'save'.


/*!\brief Builds computational object from a UserInfo structure

Return value is a pointer to the created object (memory management issue?)
/

*/
class UI 
{
private:
        //! static class encalupsating map of names to related UserInfos
        //! 
        //! The key property of this class is that it initilaized the internal map immediately
        //! when it is used for a first time.
        class Class_To_UI
        {
        private:
                //! Type definition of mapping which transforms type names to the related user infors
                typedef map< const string, UI* > Class_To_UI_Map;

                //! immediately initialized instance of type Class_To_UI_Map
                static Class_To_UI_Map& private_map();

        public:
                //! add a pair key-userinfo into the internal map
                static void add_class( const string &class_name, UI* ui );

                //! search for an userinfo related to the passed key within the internal map
                static UI* retrieve_ui( const string &class_name );
        };
                                
        //! internal method assembling a typeless instance from components obtained by the 'AssemblyComponentsFromSetting()' method
        virtual bdmroot* new_instance() = 0;
        
        //! type name defined by user
        const string class_name;

        //! This methods tries to save an instance of type T (or some of its descendant types)
        //! and build DOM tree accordingly. Then, it creates a new DOMNode named according class_name
        //! and connecti it to the passed Setting as a new child node.
        template<class T> static void to_setting( const T &instance, Setting &root )
        {
                const string &class_name = Particular_UI<T>::ui.class_name;
                        
                // add attribute "class" 
                Setting &type = root.add( "class", Setting::TypeString );
                type = class_name;
        
                try
                {
                        // instance disassembling 
                        instance.to_setting( root );
                }
                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 T* from_setting( const Setting &element )
        {                       
                const Link_Expander link_expander( element );
                const Setting &root = link_expander.root();

                ASSERT_UITYPE(root,TypeGroup);

                // we get a velue stored in the "class" attribute 
                string class_name;
                if( !root.lookupValue( "class", class_name ) )
                        ui_error( "the obligatory ""class"" identifier is missing", root );
        
                // and finally we find a UserInfo related to this type
                UI* related_UI = Class_To_UI::retrieve_ui( class_name );
                if( !related_UI)
                        it_error ( "UI error: class " + class_name + " was not properly registered. Use the macro ""UIREGISTER([class name]);"" within your code." );
                
                bdmroot* typeless_instance = related_UI->new_instance();

                T* ui = NULL;
                try
                {
                        ui = (T*) typeless_instance ;
                }
                catch(...)
                {
                        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 assembling 
                        ui->from_setting( root );
                }
                catch(SettingException xcptn)
                {
                        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." );
                }
                return ui;
        }       


        // vraci true, kdyz to byl platny link, jinak false.. v pripade chyby konci it_errorem..
        // do elementu vrati setting prislusny po rozbaleni linku, jinak ponecha beze zmeny
        class Link_Expander     
        {
        private:
                UI_File *file;
                const Setting *result;

        public:

                Link_Expander( const Setting &potential_link )
                {
                        file = NULL;
                        result = &potential_link;

                        if( potential_link.getType() !=  Setting::TypeString )
                                return;

                        string link = (string) potential_link;
                        size_t aerobase = link.find('@');
                        if( aerobase != string::npos )
                        {
                                string file_name = link.substr( aerobase + 1, link.length() );
                                file = new UI_File( file_name );
                                file->load();
                                result = &(Setting&)(*file);
                                link = link.substr( 0, aerobase );
                        }
                        else
                                while ( !result->isRoot() ) 
                                        result = &result->getParent();

                        if( !result->exists( link ) )
                                ui_error( "linked Setting was not found", potential_link );

                        result = &(*result)[link];
                }

                ~Link_Expander()
                {
                        if( file ) delete file;
                }
                
                const Setting& root() const
                {
                        return *result;
                }
        };

                static const Setting* to_child_setting( const Setting &element, const int index )
                {
                        if( !element.isAggregate())
                                return NULL;

                        if( element.getLength() <= index )
                                return NULL;

                        return &element[index];
                }

                static const Setting* to_child_setting( const Setting &element, const string &name )
                {
                        if( !element.isGroup() )
                                return NULL;

                        if( !element.exists( name ) )
                                return NULL;

                        return &element[name];
                }

                static Setting& to_child_setting( Setting &element, const int index )
                {
                        if( !element.isAggregate())
                                ui_error( "it is not possible to index non-agregate element by integers", element );

                        if( element.getLength() <= index )
                                ui_error( "there is not any child with index " + index, element );

                        return element[index];
                }

                static Setting& to_child_setting( Setting &element, const string &name )
                {
                        ASSERT_UITYPE(element,TypeGroup);
                        if( !element.exists( name ) )
                                ui_error( "there is not any child named """ + name, element );
                        return element[name];
                }

        //! This methods tries to build a new double matrix 
        static void from_setting( mat& matrix, const Setting &element )
        {
                const Link_Expander link_expander( element );
                const Setting &root = link_expander.root();

                if( root.isNumber() )
                {
                        matrix.set_size( 1, 1 );
                        matrix(0,0) = root;
                        return;
                }

                if( root.isList() )
                {
                        if( root.getLength() != 3 )
                                ui_error( "the setting supposed to represent a matrix element has wrong syntax", root );

                        Setting &cols_setting = root[0];
                        Setting &rows_setting = root[1];
                        Setting &elements = root[2];

                        ASSERT_UITYPE(cols_setting,TypeInt);
                        ASSERT_UITYPE(rows_setting,TypeInt);
                        ASSERT_UITYPE(elements,TypeArray);

                        int cols = cols_setting;
                        int rows = rows_setting;
                                                
                        if( cols < 0 | rows < 0 )
                                ui_error( "the dimensions of a matrix has to be non-negative", root );

                        if( elements.getLength() != cols * rows )
                                ui_error( "the count of the matrix elements is incompatible with matrix dimension", elements );

                        matrix.set_size( rows, cols );

                        if( cols == 0 || rows == 0 )
                                return;

                        if( !elements[0].isNumber() )
                                ui_error( "matrix elements have to be numbers", elements[0] );

                        // build matrix row-wise
                        int k = 0;
                        for( int i=0;i<rows;i++ ) 
                                for( int j=0; j<cols; j++)
                                        matrix(i,j) = elements[k++];
                        return;
                }

                ui_error( "only numeric types or TypeList are supported as matrix values", root );
        }

        //! This methods tries to save a double matrix 
        static void to_setting( const mat &matrix, Setting &root )
        {
                Setting &cols = root.add( Setting::TypeInt );
                cols = matrix.cols();

                Setting &rows = root.add( Setting::TypeInt );
                rows = matrix.rows();

                Setting &elements = root.add( Setting::TypeArray );

                // build matrix row-wise
                for( int i=0; i<matrix.rows(); i++ ) 
                        for( int j=0; j<matrix.cols(); j++)
                        {
                                Setting &newField = elements.add(Setting::TypeFloat);
                                newField = matrix(i,j);
                        }
        }

        //! This methods tries to build a new integer vector
        static void from_setting( ivec &vec, const Setting &element )
        {
                const Link_Expander link_expander( element );
                const Setting &root = link_expander.root();

                if( root.isNumber() )
                {
                        ASSERT_UITYPE(root,TypeInt);
                        vec.set_length( 1 );
                        vec(0) = root;
                        return;
                }

                if( root.isList() )
                {
                        if( root.getLength() != 3 )
                                ui_error( "the setting supposed to represent a matrix element has wrong syntax", root );

                        Setting &cols_setting = root[0];
                        Setting &rows_setting = root[1];
                        Setting &elements = root[2];

                        ASSERT_UITYPE(cols_setting,TypeInt);
                        ASSERT_UITYPE(rows_setting,TypeInt);
                        ASSERT_UITYPE(elements,TypeArray);

                        int cols = cols_setting;
                        int rows = rows_setting;
                        
                        if( cols < 0 | rows < 0)
                                ui_error( "the dimensions of a matrix has to be non-negative", root );

                        if( elements.getLength() != cols * rows )
                                ui_error( "the count of the matrix elements is incompatible with matrix dimension", elements );

                        if( cols != 1 & rows !=1)
                                ui_error( "the vector length is invalid, it seems to be rather a matrix", elements );
                        
                        int len = rows * cols;
                        vec.set_length ( len );
                        if( len == 0 ) return;

                        ASSERT_UITYPE(elements[0],TypeInt);
                        for( int i=0; i<len; i++ ) 
                                vec(i) = elements[i];
                        return;
                }

                if( root.isArray() )
                {       
                        int len = root.getLength();
                        vec.set_length( len );
                        if( len == 0 ) return;

                        ASSERT_UITYPE(root[0],TypeInt);
                        for( int i=0; i < len; i++ ) 
                                vec(i) = root[i];
                        return;
                }

                ui_error( "only numeric types, TypeArray or TypeList are supported as vector values", root );
        }

        //! This methods tries to save an integer vector
        static void to_setting( const ivec &vec, Setting &root )
        {
                for( int i=0; i<vec.length(); i++ ) 
                {
                        Setting &newField = root.add(Setting::TypeInt);
                        newField = vec(i);
                }
        }

        //! This methods tries to build a new array of strings 
        static void from_setting( Array<string> &string_array, const Setting &element )
        {
                const Link_Expander link_expander( element );
                const Setting &root = link_expander.root();

                if( root.getType() == Setting::TypeString )
                {
                        string_array.set_length( 1 );
                        string_array(0) = (string)root;
                        return;
                }

                if( root.isArray() )
                {
                        int len = root.getLength();
                        string_array.set_length( len );
                        if( len == 0 ) return;

                        ASSERT_UITYPE(root[0],TypeString);
                        for( int i=0; i < len; i++ ) 
                                string_array(i) = (string)root[i];
                        return;
                }

                ui_error( "only TypeString or TypeArray are supported as vector of string values", root );
        }

        //! This methods tries to save an array of strings
        static void to_setting( const Array<string> &string_array, Setting &root )
        {
                for( int i=0; i<string_array.length(); i++ ) 
                {
                        Setting &newField = root.add(Setting::TypeString);
                        newField = string_array(i);
                }
        }

protected:

        //! default constructor 
        UI( const string& class_name ) : class_name ( class_name )
        {       
                Class_To_UI::add_class( class_name, this );
        }

        //! Virtual destructor for future use;
        virtual ~UI(){};

public: 

        static void ui_error( string message, const Setting &element )
        {
                stringstream error_message;
                error_message << "UI ui_error: " << message << "! Check path """ << element.getPath() << """, source line " << element.getSourceLine() << ".";
                it_error ( error_message.str() );
        }

        //! This methods tries to build a new instance of type T (or some of its descendant types)
        //! according to a data stored in a DOMNode named class_name within a child nodes of the passed element.
        //! If an ui_error occurs, it returns a NULL pointer.

        //! Prototype of a UI builder. Return value is by the second argument since it type checking via \c dynamic_cast.
        template<class T> static T* build( Setting &element, const int index )
        {
                return from_setting<T>( to_child_setting( element, index ) );
        }

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

        //! This methods tries to save an instance of type T (or some of its descendant types)
        //! and build DOM tree accordingly. Then, it creates a new DOMNode named according class_name
        //! and connecti it to the passed Setting as a new child node.
        template<class T> static void save( T &instance, Setting &element, const string &name = "")
        {
                Setting &root = (name == "") ? element.add( Setting::TypeGroup )                                                        
                                                                         : element.add( name, Setting::TypeGroup );             
                to_setting( instance, root );
        }

        //! This methods tries to build a new double matrix 
        static bool get( mat& matrix, const Setting &element, const string &name )
        {
                const Setting *root = to_child_setting( element, name );
                if( !root ) return false;                               
                from_setting( matrix, *root );
                return true;
        }

        //! This methods tries to build a new double matrix 
        static bool get( mat& matrix, const Setting &element, const int index )
        {
                const Setting *root = to_child_setting( element, index );
                if( !root ) return false;                               
                from_setting( matrix, *root );
                return true;
        }

        //! This methods tries to save a double matrix 
        static void save( mat &matrix, Setting &element, const string &name = "" )
        {
                Setting &root = (name == "") ? element.add( Setting::TypeList )                                                 
                                                                         : element.add( name, Setting::TypeList );              
                to_setting( matrix, root );
        }

        //! This methods tries to build a new double vec 
        static bool get( ivec& vec, const Setting &element, const string &name )
        {
                const Setting *root = to_child_setting( element, name );
                if( !root ) return false;                               
                from_setting( vec, *root );
                return true;
        }

        //! This methods tries to build a new double vec 
        static bool get( ivec& vec, const Setting &element, const int index )
        {
                const Setting *root = to_child_setting( element, index );
                if( !root ) return false;                               
                from_setting( vec, *root );
                return true;
        }

        //! This methods tries to save a double vec 
        static void save( ivec &vec, Setting &element, const string &name = "" )
        {
                Setting &root = (name == "") ? element.add( Setting::TypeArray )                                                        
                                                                         : element.add( name, Setting::TypeArray );             
                to_setting( vec, root );
        }

        //! This methods tries to build a new double string_array 
        static bool get( Array<string> &string_array, const Setting &element, const string &name )
        {
                const Setting *root = to_child_setting( element, name );
                if( !root ) return false;                               
                from_setting( string_array, *root );
                return true;
        }

        //! This methods tries to build a new double string_array 
        static bool get( Array<string> &string_array, const Setting &element, const int index )
        {
                const Setting *root = to_child_setting( element, index );
                if( !root ) return false;                               
                from_setting( string_array, *root );
                return true;
        }

        //! This methods tries to save a double string_array 
        static void save( Array<string> &string_array, Setting &element, const string &name = "" )
        {
                Setting &root = (name == "") ? element.add( Setting::TypeArray )                                                        
                                                                         : element.add( name, Setting::TypeArray );             
                to_setting( string_array, root );
        }
};


/*!
@brief The main userinfo template class. You should derive this class whenever you need 
a new userinfo of a class which is compound from smaller elements (all having its
own userinfo class prepared).
*/
template<typename T> class Particular_UI : private UI
{
        // to permit acces to the Particular_UI<T>::ui to the UI class
        friend UI;

        //! default constructor, which is intentionally declared as private
        Particular_UI<T>( const string &class_name) : UI( class_name ) 
        {       
        };

        //! the only instance of this class (each type T has its own instance)
        //! which is used as a factory for processing related UI
        static Particular_UI<T>& ui;    

        bdmroot* new_instance()
        {
                return new T();
        }
};


}

/*! Recursive build of objects defined in the same file

\code 
{type="internal";
path="system.profile.[0]";    // Path from the root 
};
\endcode
 */



/*! Recursive build of objects defined in external file

\code 
{type="external";
filename="my_file.cfg";       // name of file from which to read
path="system.profile.[0]";    // Path in the external file
};
\endcode
/

*/

#endif // #ifndef UIBUILD