Changeset 344

Timestamp:

05/20/09 14:42:05 (15 years ago)

Author:

mido

Message:

funkcni verze noveho UI, zbyva jeste ucesat

Files:

• bdm/stat/libBM.h (modified) (3 diffs)
• bdm/uibuilder.cpp (modified) (5 diffs)
• bdm/uibuilder.h (modified) (3 diffs)
• tests/UI/UIbuilder_test.cfg (modified) (1 diff)
• tests/UI/UIbuilder_test.cpp (modified) (1 diff)
• tests/UI/UIbuilder_test_ex.cfg (modified) (1 diff)

bdm/stat/libBM.h

@@ -16 +16 @@
 
 #include "../itpp_ext.h"
-#include "libconfig/libconfig.h++"
+#include "../libconfig/libconfig.h++"
 #include <map>
 
@@ -35 +35 @@
         }
 
+        //! This method returns a basic info about the current instance
         virtual string ToString()
         {
@@ -41 +42 @@
 
         //! This method arrange instance properties according the data stored in the Setting structure
-        virtual void FromSetting( Setting &root )
+        virtual void FromSetting( const Setting &root )
         {
         }

bdm/uibuilder.cpp

@@ +1 @@
+//
+// C++ Implementation: itpp_ext
+//
+// Description:
+//
+//
+// Author: smidl <smidl@utia.cas.cz>, (C) 2008
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+
+#include "uibuilder.h"
+
+namespace bdm {
+
+UI::StringToUIMap::MappedString2UI& UI::StringToUIMap::privateMap()
+{
+        static MappedString2UI var;
+        return var;
+}
+
+void UI::StringToUIMap::Add( const string &className, pUI pInstance )
+{
+        privateMap().insert( make_pair( className, pInstance ) );
+}
+
+UI::pUI UI::StringToUIMap::Retrieve( const string &className )
+{
+        MappedString2UI::const_iterator iter = privateMap().find( className );
+        if( iter == privateMap().end()) return NULL;
+        else return iter->second;
+}       
+
+//////////////////////////////////////////////////////////////////////
+
+
+UIFile::UIFile ( const string &file_name ) : fileName( file_name )
+{
+        Config::setAutoConvert( true );
+}
+
+//! loads root element from a file
+void UIFile::Load() 
+{
+        try
+        {
+                Config::readFile( fileName.c_str()  );
+        }
+        catch ( FileIOException f ) 
+        {
+                it_error ( "UI: file " + fileName + " not found." );
+        }
+        catch ( ParseException& P ) 
+        {
+                stringstream msg;
+                msg << "UI: parsing error """ << P.getError() << """ in file " << fileName << " on line " <<  P.getLine() << ".";
+                it_error ( msg.str() );
+        }       
+}
+
+
+//! Save UserInfo to the file (typically with an XML extension)
+void UIFile::Save()
+{
+        try
+        {
+                Config::writeFile ( fileName.c_str()  );
+        }
+        catch ( FileIOException f ) 
+        {
+                it_error( "UI: file " + fileName + " is inacessible." );
+        }               
+}       
+
+UIFile::operator Setting&()
+{
+        return getRoot();
+}
+
+}
+/*
 #include "uibuilder.h"
 
@@ -4 +86 @@
 
 //! global map of UIbulder names to instances of UIbuilders. Created by UIREGISTER macro
-UImap __uimap__;
+UIbuilder::UImap UIbuilder::__uimap__;
 
 bdmroot* UIexternal::build ( Setting &S ) const {
@@ -17 +99 @@
         try {
                 Setting& remS=C.lookup ( ( const char* ) S["path"] );
-                UIbuild ( remS,tmp );
+                UIbuilder::build( remS,tmp );
         }
         catch ( ... ) {
@@ -33 +115 @@
                 while ( !Stmp->isRoot() );
                 Setting& intS=Stmp->lookup ( ( const char* ) S["path"] );
-                UIbuild ( intS,tmp );
+                UIbuilder::build( intS,tmp );
         }
         catch ( ... ) {
@@ -81 +163 @@
 }
 //UIexternal* UIexternal_instance =new UIexternal();
+*/

bdm/uibuilder.h

@@ -6 +6 @@
 #include "libconfig/libconfig.h++"
 
-namespace bdm {
-
+#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;
-using namespace std;
-
-#define CHECK_UITYPE(S,Type) it_assert_debug(S.getType()==Setting::Type, string("Wrong input path \"")+string(S.getPath())+string("\""));
-#define UIREGISTER(UI) UI* UI##_global_instance = new UI();
-
-//!Standard catches for UIs, use as: catch UICATCH
-#define UICATCH  ( SettingTypeException e ) {it_error ( "Setting " +string ( e.getPath() ) +" is of incorrect Type" );} catch ( SettingNotFoundException e ) {it_error ( "Setting " + string ( e.getPath() ) +" was not found" );}
-
-////////// GLOBAL VAriables
-
-class UIbuilder;
-//! Internal structure mapping strings to UIBuilder objects
-typedef map<const string, const UIbuilder*> UImap;
-extern UImap __uimap__;
-
-class UIFile : public Config {
+
+#define UIREGISTER(className) template<> ParticularUI<className>& ParticularUI<className>::ui = ParticularUI<className>(#className)
+
+#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 UIFile : public Config
+{
+private:
+        const string fileName;
+
 public:
-        UIFile ( const char * fname ) :Config() {
-                try{Config::readFile ( fname );}
-                catch ( FileIOException f ) {it_error ( "File " + string ( fname ) + " not found" );}
-                catch ( ParseException& P ) {
-                        char msg[200];
-                        sprintf ( msg,"Error in file %s  on line %d.", fname, P.getLine() );
+        //! attach new RootElement instance to a file (typically with an XML extension)
+        UIFile( 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 ParticularUI<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:
+        //! just a typedef shortuct for a constant pointer to UI
+        typedef UI* pUI;
+
+        //! 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 StringToUIMap
+        {
+        private:
+                //! Type definition of mapping which transforms type names to the related user infors
+                typedef map< const string, pUI > MappedString2UI;
+
+                //! immediately initialized instance of type MappedString2UI
+                static MappedString2UI& privateMap();
+
+        public:
+                //! add a pair key-userinfo into the internal map
+                static void Add( const string &className, pUI pInstance );
+
+                //! search for an userinfo related to the passed key within the internal map
+                static pUI Retrieve( const string &className );
+        };
+                                
+        //! internal method assembling a typeless instance from components obtained by the 'AssemblyComponentsFromSetting()' method
+        virtual bdmroot* New() = 0;
+        
+        //! type name defined by user
+        const string className;
+
+protected:
+
+        //! default constructor 
+        UI( const string& className ) : className ( className )
+        {       
+                StringToUIMap::Add( className, this );
+        }
+
+        //! Virtual destructor for future use;
+        virtual ~UI(){};
+
+private:
+
+        //! 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 className
+        //! and connecti it to the passed Setting as a new child node.
+        template<class T> static void ToSetting( T &instance, Setting &element )
+        {
+                string &className = ParticularUI<T>::ui.className;
+                        
+                // add attribute "class" 
+                Setting &type = root.add( "class", Setting::TypeString );
+                type = className;
+        
+                try
+                {
+                        // instance disassembling 
+                        instance.ToSetting( root );
+                }
+                catch(SettingException xcptn)
+                {
+                        it_error ( "UI: the method " + className + ".ToSetting(Setting&) has thrown an exception when filling the setting " + xcptn.getPath() + ". Try to correct this method." );
+                }       
+        }
+
+        template<class T> static T* FromSetting( const Setting &element )
+        {                       
+                RevealIfLinked revealed_link( element );
+                const Setting &root = revealed_link.root();
+
+                ASSERT_UITYPE(root,TypeGroup);
+
+                // we get a velue stored in the "class" attribute 
+                string className;
+                if( !root.lookupValue( "class", className ) )
+                {
+                        stringstream msg;
+                        msg << "UI: the class identifier is missing within the setting """ << root.getPath() <<  """. Check line " 
+                                << root.getSourceLine() << ".";
+                        it_error ( msg.str() );
+                }
+
+        
+                // and finally we find a UserInfo related to this type
+                pUI pRelatedUI = StringToUIMap::Retrieve( className );
+                if( !pRelatedUI)
+                        it_error ( "UI: class " + className + " was not properly registered. Use the macro ""UIREGISTER([class name]);"" within your code." );
+                
+                bdmroot* pTypelessInstance = pRelatedUI->New();
+
+                T* pInstance = NULL;
+                try
+                {
+                        pInstance = (T*) pTypelessInstance ;
+                }
+                catch(...)
+                {
+                        it_error ( "UI: class " + className + " is not a descendant of the desired output class. Try to call the UI::Build function with a different type parameter." );
+                }
+                
+                try
+                {
+                        // instance assembling 
+                        pInstance->FromSetting( root );
+                }
+                catch(SettingException xcptn)
+                {
+                        string msg = "UI: the method " + className + ".FromSetting(Setting&) has thrown an exception when parsing the setting " + xcptn.getPath() + ". Try to correct this method.";
                         it_error ( msg );
                 }
-        }
+                return pInstance;
+        }       
+
+
+
+public:
+
+        // 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 RevealIfLinked    
+        {
+        private:
+                UIFile *file;
+                const Setting * result;
+
+        public:
+
+                RevealIfLinked( const Setting &element )
+                {
+                        file = NULL;
+                        result = &element;
+
+                        if( element.getType() !=  Setting::TypeString )
+                                return;
+
+                        string link = (string) element;
+                        size_t aerobase = link.find('@');
+                        if( aerobase != string::npos )
+                        {
+                                string file_name = link.substr( aerobase + 1, link.length() );
+                                file = new UIFile( file_name );
+                                file->Load();
+                                // TODO OSETRIT FALSE, vyhodit iterr
+
+                                result = &(Setting&)(*file);
+
+                                link = link.substr( 0, aerobase );
+                        }
+                        else
+                                while ( !result->isRoot() ) 
+                                        result = &result->getParent();
+
+                        if( !result->exists( link ) )
+                        {
+                                // vyhodi chybu v pripade chyby
+                                printf("");
+                        }
+                        result = &(*result)[link];
+                        return;
+                }
+
+                ~RevealIfLinked()
+                {
+                        if( file ) delete file;
+                }
+
+                
+                const Setting& root()
+                {
+                        return *result;
+                }
+        };
+
+        private:
+                static const Setting* ToChildSetting( const Setting &element, const int index )
+                {
+                        if( !element.isAggregate())
+                                return NULL;
+
+                        if( element.getLength() <= index )
+                                return NULL;
+
+                        return &element[index];
+                }
+
+                static const Setting* ToChildSetting( const Setting &element, const string &name )
+                {
+                        if( !element.isGroup() )
+                                return NULL;
+
+                        if( !element.exists( name ) )
+                                return NULL;
+
+                        return &element[name];
+                }
+
+                static Setting& ToChildSetting( Setting &element, const int index )
+                {
+                        if( !element.isAggregate())
+                        {
+                                // TODO CO ZA TYP? ASI NE GROUP, COZ..
+                        }
+                        if( element.getLength() <= index )
+                        {
+                                stringstream msg;
+                                msg << "UI: there is not any child with index " << index << " in the parsed setting " 
+                                        << element.getPath() <<  ", check line " << element.getSourceLine() << ".";
+
+                                it_error ( msg.str() );
+                        }
+                        return element[index];
+                }
+
+                static Setting& ToChildSetting( Setting &element, const string &name )
+                {
+                        ASSERT_UITYPE(element,TypeGroup);
+                        if( !element.exists( name ) )
+                        {
+                                stringstream msg;
+                                msg << "UI: there is not any child named """ << name << """ in the parsed setting " 
+                                        << element.getPath() <<  ", check line " << element.getSourceLine() << ".";
+
+                                it_error ( msg.str() );
+                        }
+                        return element[name];
+                }
+
+        //! This methods tries to build a new double matrix 
+        static bool FromSetting( mat& matrix, const Setting &root )
+        {
+                ASSERT_UITYPE(root,TypeList);
+                if( root.getLength() != 3 )
+                {
+                        stringstream msg;
+                        msg << "UI: the setting " << root.getPath() <<  """ supposed to represent a matrix element has wrong syntax"". Check line " 
+                                << root.getSourceLine() << ".";
+                        it_error ( msg.str() );
+                }
+
+                Setting &cols_setting = root[0];
+                Setting &rows_setting = root[1];
+                Setting &values = root[2];
+
+                ASSERT_UITYPE(cols_setting,TypeInt);
+                ASSERT_UITYPE(rows_setting,TypeInt);
+                ASSERT_UITYPE(values,TypeArray);
+
+                int cols = cols_setting;
+                int rows = rows_setting;
+                
+                if( values.getLength() != cols * rows )
+                {
+                        stringstream msg;
+                        msg << "UI: the lenght of array containing matrix values within setting " << root.getPath() <<  """ is improper, check line " 
+                                << root.getSourceLine() << ".";
+                        it_error ( msg.str() );
+                }
+
+                matrix.set_size( rows, cols );
+
+                if( cols == 0 || rows == 0 )
+                        return true;
+
+                if( !values[0].isNumber() )
+                {
+                        stringstream msg;
+                        msg << "UI: the array containing matrix values within setting " << root.getPath() <<  """ has to contain numeric values only! Check line " 
+                                << root.getSourceLine() << ".";
+                        it_error ( msg.str() );
+                }
+
+                // Build matrix row-wise
+                int k = 0;
+                for( int i=0;i<rows;i++ ) 
+                        for( int j=0; j<cols; j++)
+                                matrix(i,j) = values[k++];
+
+                return true;
+        }
+
+        //! This methods tries to save a double matrix 
+        static void ToSetting( mat &matrix, Setting &root )
+        {
+                Setting &cols = root.add( Setting::TypeInt );
+                cols = matrix.cols();
+
+                Setting &rows = root.add( Setting::TypeInt );
+                rows = matrix.rows();
+
+                Setting &values = 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 = values.add(Setting::TypeFloat);
+                                newField = matrix(i,j);
+                        }
+        }
+
+        //! This methods tries to build a new integer vector
+        static bool FromSetting( ivec &vec, const Setting &root )
+        {
+                ASSERT_UITYPE(root,TypeArray);
+
+                int len = root.getLength();
+                vec.set_length( len );
+                if( len == 0 ) return true;
+                ASSERT_UITYPE(root[0],TypeInt);
+
+                for( int i=0; i < len; i++ ) 
+                        vec(i) = root[i];
+                
+                return true;
+        }
+
+        //! This methods tries to save an integer vector
+        static void ToSetting( 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 bool FromSetting( Array<string> &string_array, const Setting &root)
+        {
+                ASSERT_UITYPE(root,TypeArray);
+
+                int len = root.getLength();
+                string_array.set_length( len );
+                if( len == 0 ) return true;
+                ASSERT_UITYPE(root[0],TypeString);
+
+                for( int i=0; i < len; i++ ) 
+                        string_array(i) = (string)root[i];
+
+                return true;
+        }
+
+        //! This methods tries to save an array of strings
+        static void ToSetting( 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);
+                }
+        }
+
+public: 
+
+        //! 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 className within a child nodes of the passed element.
+        //! If an 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 FromSetting<T>( ToChildSetting( element, index ) );
+        }
+
+        template<class T> static T* Build( Setting &element, const string &name )
+        {                       
+                return FromSetting<T>( ToChildSetting( 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 className
+        //! and connecti it to the passed Setting as a new child node.
+        template<class T> static void Save( T &instance, Setting &element )
+        {
+                Setting &root = element.add( Setting::TypeGroup );              
+                ToSetting( instance, root );
+        }
+
+        //! 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 className
+        //! 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 = element.add( name, Setting::TypeGroup );                
+                ToSetting( 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 = ToChildSetting( element, name );
+                if( !root ) return false;                               
+                return FromSetting( matrix, *root );
+        }
+
+        //! This methods tries to build a new double matrix 
+        static bool Get( mat& matrix, const Setting &element, const int index )
+        {
+                const Setting *root = ToChildSetting( element, index );
+                if( !root ) return false;                               
+                return FromSetting( matrix, *root );
+        }
+
+        //! This methods tries to save a double matrix 
+        static void Save( mat &matrix, Setting &element, const string &name )
+        {
+                Setting &root = element.add( name, Setting::TypeList );         
+                ToSetting( matrix, root );
+        }
+
+        //! This methods tries to save a double matrix 
+        static void Save( mat &matrix, Setting &element )
+        {
+                Setting &root = element.add( Setting::TypeList );               
+                ToSetting( 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 = ToChildSetting( element, name );
+                if( !root ) return false;                               
+                return FromSetting( vec, *root );
+        }
+
+        //! This methods tries to build a new double vec 
+        static bool Get( ivec& vec, const Setting &element, const int index )
+        {
+                const Setting *root = ToChildSetting( element, index );
+                if( !root ) return false;                               
+                return FromSetting( vec, *root );
+        }
+
+        //! This methods tries to save a double vec 
+        static void Save( ivec &vec, Setting &element, const string &name )
+        {
+                Setting &root = element.add( name, Setting::TypeArray );                
+                ToSetting( vec, root );
+        }
+
+        //! This methods tries to save a double vec 
+        static void Save( ivec &vec, Setting &element)
+        {
+                Setting &root = element.add( Setting::TypeArray );              
+                ToSetting( 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 = ToChildSetting( element, name );
+                if( !root ) return false;                               
+                return FromSetting( string_array, *root );
+        }
+
+        //! 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 = ToChildSetting( element, index );
+                if( !root ) return false;                               
+                return FromSetting( string_array, *root );
+        }
+
+        //! This methods tries to save a double string_array 
+        static void Save( Array<string> &string_array, Setting &element, const string &name )
+        {
+                Setting &root = element.add( name, Setting::TypeArray );                
+                ToSetting( string_array, root );
+        }
+
+        //! This methods tries to save a double string_array 
+        static void Save( Array<string> &string_array, Setting &element )
+        {
+                Setting &root = element.add( Setting::TypeArray );              
+                ToSetting( string_array, root );
+        }
+
+
 };
 
-//! \name elem Elementary build functions
-//!@{
-
-//! construct itpp::vec from Setting of type Array
-inline vec getvec ( Setting& S ) {
-        vec vector;
-        if (S.getType() == Setting::TypeArray) {        
-                vector.set_size ( S.getLength() );
-                for ( int i=0;i<S.getLength();i++ ) {
-                        switch ( S[i].getType() ) {
-                                case Setting::TypeFloat :
-                                        vector[i]=double ( S[i] );break;
-                                case Setting::TypeInt :
-                                        vector[i]=int ( S[i] );break;
-                                case Setting::TypeBoolean :
-                                        vector[i]=bool ( S[i] );break;
-                                default: it_error ( "libconfig error?" );
-                        }
-                }
-        } else if (S.getType() == Setting::TypeGroup) {
-                vector = getvec(S["elements"]);
-                int cols = S["cols"];
-                if (vector.length() != cols) { 
-                        it_error("requested vector is a matrix");
-                }
-        } else {
-                it_error("requested vector has invalid type");
-        }
-        return vector;
+
+/*!
+@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 ParticularUI : private UI
+{
+        // to permit acces to the ParticularUI<T>::ui to the UI class
+        friend UI;
+
+        //! default constructor, which is intentionally declared as private
+        ParticularUI<T>( const string &className) : UI( className ) 
+        {       
+        };
+
+        //! the only instance of this class (each type T has its own instance)
+        //! which is used as a factory for processing related UI
+        static ParticularUI<T>& ui;     
+
+        bdmroot* New()
+        {
+                return new T();
+        }
 };
 
-//! construct itpp::mat from Setting of type Array, number of columns must be given
-inline mat getmat ( Setting& S , int ncols ) {
-        CHECK_UITYPE ( S,TypeArray );
-        mat tmp;
-        int nrows=S.getLength() /ncols;
-        int r=0,c=0;
-        tmp.set_size ( nrows, ncols );
-        // Build matrix row-wise
-        for ( int i=0;i<S.getLength();i++ ) {
-                switch ( S[i].getType() ) {
-                        case Setting::TypeFloat :
-                                tmp ( r,c ) =double ( S[i] );break;
-                        case Setting::TypeInt :
-                                tmp ( r,c ) =int ( S[i] );break;
-                        case Setting::TypeBoolean :
-                                tmp ( r,c ) =bool ( S[i] );break;
-                        default: it_error ( "libconfig error?" );
-                }
-                c++; if ( c==ncols ) {c=0;r++;}
-        }
-        return tmp;
+
+}
+
+/*! Recursive build of objects defined in the same file
+
+\code 
+{type="internal";
+path="system.profile.[0]";    // Path from the root 
 };
-
-//! construct itpp::mat from Setting of type Group containing settings
-//! "elements" and "cols"
-inline mat getmat (Setting & S) {
-        CHECK_UITYPE (S, TypeGroup);
-        return getmat(S["elements"], S["cols"]);
-}
-
-//! construct itpp::ivec from Setting of type Array
-
-inline ivec getivec ( Setting& S ) {
-        CHECK_UITYPE ( S,TypeArray );
-        ivec tmp;
-        tmp.set_size ( S.getLength() );
-        for ( int i=0;i<S.getLength();i++ ) {
-                switch ( S[i].getType() ) {
-                        case Setting::TypeFloat :
-                                tmp[i]=double ( S[i] );break;
-                        case Setting::TypeInt :
-                                tmp[i]=int ( S[i] );break;
-                        case Setting::TypeBoolean :
-                                tmp[i]=bool ( S[i] );break;
-                        default: it_error ( "libconfig error?" );
-                }
-        }
-        return tmp;
-};
-
-//! construct itpp::Array<string> from Setting of type Array
-
-inline Array<string> get_as ( Setting& S ) {
-        CHECK_UITYPE ( S,TypeArray );
-        Array<string> tmp;
-        tmp.set_size ( S.getLength() );
-        for ( int i=0;i<S.getLength();i++ ) {tmp ( i ) = ( const char* ) S[i];}
-        return tmp;
-};
-
-//!@}
-
-/*!\brief Builds computational object from a UserInfo structure
-
-Return value is a pointer to the created object (memory management issue?)
-*/
-class UIbuilder {
-protected:
-public:
-        //!Constructor needs to be run only once macro UIREGISTER
-        UIbuilder ( const string &typ ) {__uimap__.insert ( make_pair ( typ,this ) );}
-        //! Function building the computational object
-        virtual bdmroot* build ( Setting &S ) const =0;
-        //! Virtual destructor for future use;
-        virtual ~UIbuilder(){};
-};
+\endcode
+ */
+
+
 
 /*! Recursive build of objects defined in external file
@@ -153 +615 @@
 };
 \endcode
-*/
-class UIexternal:public UIbuilder {
-public:
-        UIexternal() :UIbuilder ( "external" ) {}
-        bdmroot* build ( Setting &S ) const;
-};
-
-/*! Recursive build of objects defined in the same file
-
-\code 
-{type="internal";
-path="system.profile.[0]";    // Path from the root 
-};
-\endcode
- */
-class UIinternal:public UIbuilder {
-public:
-        UIinternal() :UIbuilder ( "internal" ) {}
-        bdmroot* build ( Setting &S ) const;
-};
+/
+
 
 //! [Debugging] Print values in current S to cout
 void UI_DBG ( Setting &S, const string &spc );
 
-//! Prototype of a UI builder. Return value is by the second argument since it type checking via \c dynamic_cast.
-template<class T>
-void UIbuild ( Setting &S, T* &ret ) {
-        CHECK_UITYPE ( S,TypeGroup );
-        // Check if field "type" is present, if not it is not a valid UI
-        it_assert_debug ( S.exists ( "type" ), string ( S.getPath() ) +" is not a valid UI!" );
-
-        const string typ=S["type"];
-        // Find "type" in list of registred UI builders
-        UImap::const_iterator iter = __uimap__.find ( typ );
-        if ( iter == __uimap__.end() ) {
-                it_error ( "UI of type \"" + typ + "\" is not registered!" );
-        }
-
-        //BUILD the result
-        try {
-                ret = dynamic_cast<T*> ( iter->second->build ( S ) );
-        }
-        catch UICATCH
-};
-
+
+/*
 //! Auxiliary function allowing recursivity in S (too complex, remove?)
 template<class T>
 void UIcall ( Setting &S, void ( *func ) ( Setting&, T ), T Tmp ) {
-        CHECK_UITYPE ( S,TypeGroup );
-        // Check if field "type" is present, if not it is not a valid UI
-        it_assert_debug ( S.exists ( "type" ), string ( S.getPath() ) +" is not a valid UI!" );
-
-        const string typ=S["type"];
+        ASSERT_UITYPE ( S,TypeGroup );
+        // Check if field "class" is present, if not it is not a valid UI
+        it_assert_debug ( S.exists ( "class" ), string ( S.getPath() ) +" is not a valid UI!" );
+
+        const string typ=S["class"];
         if ( typ=="internal" ) {
                 try {
@@ -235 +660 @@
 
 }
-#endif //UIBUILD
+
+*/
+
+#endif // #ifndef UIBUILD

tests/UI/UIbuilder_test.cfg

@@ -1 +1 @@
 //test
-test:
+pepikovo : 
 {
-type= "test";
-a= 1;
-S= "hello!!!";
+  class = "Car";
+  year = 1998;
+  manufacturer = "audi";
+  kilometers = 25000;
 };
-test2:
+jardovo : 
 {
-type= "internal";
-path="int";
+  class = "Car";
+  year = 1992;
+  manufacturer = "liaz";
+  kilometers = 1555000;
 };
-test3:
+ondrejovo : 
 {
-type= "external";
-filename = "UIbuilder_test_ex.cfg";
-path="test2";
+  class = "Bike";
+  year = 1996;
+  manufacturer = "author";
+  electricLights = true;
+  matr = ( 2, 2, [ 1.0, 0.0, 0.0, 1.0 ] );
 };
-int:
-{
-type= "test2";
-a= 1;
-S= "yeah!!!";
-};
+elisky : "jardovo";
+kati : "skubankovo@UIbuilder_test_ex.cfg";

tests/UI/UIbuilder_test.cpp

@@ -1 +1 @@
 #include <uibuilder.h>
+#include <string>
 
-using namespace libconfig;
+using std::string;
 using namespace std;
 using namespace bdm;
 
-class cls :public bdmroot{
-        public:
-                int a;
-                string S;
-                cls(int a0, string S0):a(a0),S(S0){};
-                virtual void print(){cout << a << " and "<< S << endl;}
-};
-class cls2: public cls{
-        public:
-        cls2(int a0, string S0):cls(a0,S0){};
-        void print(){cout << a << " or "<< S << endl;}
+class Transport : public bdmroot
+{
+public:
+        int year;
+        string manufacturer;
+
+        Transport()
+        {
+                year = 1900;
+                manufacturer = "unknown";
+        }
+
+        Transport( int year, string manufacturer )
+                : year( year ), manufacturer( manufacturer )
+        {
+        }
+
+        virtual void FromSetting( const Setting &root )
+        {
+                root.lookupValue( "year", year );
+                root.lookupValue( "manufacturer", manufacturer );
+        }
+
+        virtual void ToSetting( Setting &root ) 
+        {       
+                Setting &year_setting = root.add("year", Setting::TypeInt );
+                year_setting = year;
+
+                Setting &manufacturer_setting = root.add("manufacturer", Setting::TypeString );
+                manufacturer_setting = manufacturer;    
+        }
 };
 
-class UItest : public UIbuilder{
-        public:
-        UItest():UIbuilder("test"){}
-        bdmroot* build(Setting &S) const{
-                        int a=S["a"];
-                        string St;
-                        S.lookupValue("S",St);
-                        cls* tmp = new cls(a,St);
-                        return tmp;
-        }       
+class Car : public Transport
+{
+public:
+        int kilometers;
+
+        Car() : Transport()               
+        {
+                kilometers = 0;
+        }
+
+
+        Car( int year, string manufacturer, int kilometers )
+                : Transport( year, manufacturer ), kilometers( kilometers )
+        {
+        }
+
+        virtual void FromSetting( const Setting &root ) 
+        {       
+                Transport::FromSetting( root );
+
+                root.lookupValue( "kilometers", kilometers );
+        }
+
+        virtual void ToSetting( Setting &root ) 
+        {       
+                Transport::ToSetting( root );
+
+                Setting &kilometers_setting = root.add("kilometers", Setting::TypeInt );
+                kilometers_setting = kilometers;
+        }
+
+        string ToString()
+        {
+                stringstream stream;
+                stream << "a car made in " << year << " by " << manufacturer << ", having " << kilometers << " kilometers on the clock.";
+                return stream.str();
+        }
 };
 
-class UItest2 : public UIbuilder{
-        public:
-        UItest2():UIbuilder("test2"){}
-        bdmroot* build(Setting &S) const{
-                        int a=S["a"];
-                        string St;
-                        S.lookupValue("S",St);
-                        return  new cls2(a,St);
-        }       
-        int no(){return 2;}
+UIREGISTER(Car);
+
+class Bike : public Transport
+{
+public:
+        bool electricLights;
+        mat matr;
+
+        Bike() : Transport(), matr("2,2;3,4")
+        {
+                electricLights = false;         
+        }
+
+        Bike( int year, string manufacturer, bool electricLights )
+                : Transport( year, manufacturer ), electricLights( electricLights )
+        {
+        }
+
+        ~Bike()
+        {
+        }
+
+        void FromSetting( const Setting &root ) 
+        {       
+                Transport::FromSetting( root );
+
+                root.lookupValue( "electricLights", electricLights );
+
+                UI::Get( matr, root, "matr" );
+        }
+
+        void ToSetting( Setting &root ) 
+        {       
+                Transport::ToSetting( root );
+
+                Setting &electricLights_setting = root.add("electricLights", Setting::TypeBoolean );
+                electricLights_setting = electricLights;
+
+                UI::Save( matr, root, "matr" );
+        }
+
+        string ToString()
+        {
+                stringstream stream;
+                stream << "a bike made in " << year << " by " << manufacturer;
+                if( electricLights ) stream << " with electric lights included";                                                
+                return stream.str();
+        }
 };
 
-UIREGISTER(UItest);
-UIREGISTER(UItest2);
-//UItest* UItest_instance = new UItest();
-//UItest2* UItest2_instance = new UItest2();
+UIREGISTER(Bike);
 
-int main(){
-UIFile UI("UIbuilder_test.cfg");
+int main()
+{       
+        /////////////////////////////////// SAVING //////////////////////////
+        /*
+        Car audi( 1998, "audi", 25000);
+        Car liaz( 1992, "liaz", 1555000);
+        Bike author( 1996, "author", true );
 
-cls* Cls;
-UIbuild(UI.lookup("test"),Cls);
-cls* Cls2;
-UIbuild(UI.lookup("test2"),Cls2);
-cls* Cls3;
-UIbuild(UI.lookup("test3"),Cls3);
+        UIFile root("UIbuilder_test.cfg");      
+        UI::Save( audi, root, "pepikovo");
+        UI::Save( liaz, root, "jardovo"); 
+        UI::Save( author, root, "ondrejovo");
+        root.Save();
 
-Cls->print();
-Cls2->print();
-Cls3->print(); 
-
-delete Cls;
-delete Cls2;
-delete Cls3;
+        cout << "all the transport means were saved correctly" << endl;                         
+        getchar();
+        */
+        
+        //////////////////////////////////// LOADING ////////////////////////////////
+        UIFile root("UIbuilder_test.cfg");      
+        root.Load();
+        Transport *pepikovo = UI::Build<Transport>( root, "pepikovo");  
+        cout << "pepikovo: " << pepikovo->ToString() << endl;           
+        Transport *jardovo = UI::Build<Transport>( root, "jardovo");    
+        cout << "jardovo: " << jardovo->ToString() << endl;             
+        Transport *ondrejovo = UI::Build<Transport>( root, "ondrejovo");        
+        cout << "ondrejovo: " << ondrejovo->ToString() << endl;         
+        Transport *elisky = UI::Build<Transport>( root, "elisky");      
+        cout << "elisky: " << elisky->ToString() << endl;               
+        Transport *kati = UI::Build<Transport>( root, "kati");  
+        cout << "kati: " << kati->ToString() << endl;           
+        getchar(); 
+        return 0;
 }

tests/UI/UIbuilder_test_ex.cfg

@@ -1 @@
-test2:
+skubankovo : 
 {
-type= "test2";
-a= 1;
-S= "distant hello!!!";
+  class = "Car";
+  year = 1980;
+  manufacturer = "vecernicek";
+  kilometers = 250000;
 };