Changeset 156

Timestamp:

09/01/08 15:08:50 (16 years ago)

Author:

mido

Message:

okomentovani UI

Files:

• bdm/userinfo.h (modified) (23 diffs)
• tests/testUI.cpp (modified) (2 diffs)

bdm/userinfo.h

@@ -27 +27 @@
 
 /*!
-@brief Xerces interface class
-
-This class is used to interact with the Xerces library.
+@brief Class initializing Xerces library
+
+This class is used to initialize the Xerces library. Namely
+to call static method XMLPlatformUtils::Initialize(). It should
+be called just once, at previously to any other usage of the Xerces
+library. This behaviour is assured by a quite complicated design
+based on the use of an inner singleton class named 'XercesConnector'.
+The point is to be the first initialized class even within the set of all
+(global) static variables. For better understanding, find instances of
+this class and look at their context.
 */
-/// TODO slo by i bez vnorene tridy?
 class AssertXercesIsAlive
 {
 private:
+        //! Singleton class implementing the key property of the 'AssertXercesIsAlive' class 
         class XercesConnector
         {
         private:
-                //!default constructor
+                //! Default constructor, which is intentionally declared as private and called only from static
+                //! method 'StayAlive()'. Therfore, it is called only once in the run of a application!
                 XercesConnector()
                 {
@@ -52 +60 @@
 
         public:
-                //! The only global instance of the XercesConnector class
-                // potrebujeme inicializaci hned v okamziku zavolani!!
+                //! This method just touches the only instance of the XercesConnector class
+                //! which is declared as a static local variable.
+                //!
+                //! This way we know that Xerces was initialized properly when returning from StayAlive().
+                //! And what is more, the local nature of the inner variable prevents us before multiple 
+                //! initializations.
                 static void StayAlive()
                 {
@@ -62 +74 @@
 
 public:
+        //!default constructor
         AssertXercesIsAlive()
         {
@@ -68 +81 @@
 };
 
-
+/*!
+@brief Abstract class declaring general properties of a frame for data binding 
+*/
 class BindingFrame
 {
 private:
-        // okomentovat, ze musi byt prvni
+        //! This private attribute has to be declared as the first attribute in the class.
+        //! Only this way we can be sure it's constructor is called as the first
+        //! and thus Xerces is initialized properly and right on time
         AssertXercesIsAlive dummy;
+
 protected:
+        //!default constructor
         BindingFrame();
 
-        //! function transcodes Xerces' XMLCh-based strings into C++ strings
+        //! function which transcodes Xerces' XMLCh-based strings into C++ strings
         string XMLCh2str( const XMLCh* const  XMLCh_str );
 
+        string removeSpaces(const string &str) 
+        {
+                std::string temp;
+                for (unsigned int i = 0; i < str.length(); i++)
+                        if (str[i] == ' ') temp += '_';
+                        else temp += str[i];
+                return temp;
+        }
+
 public: 
-        // nacpe na prislusne pointery, kdyztak da NULL
-        virtual void AssemblyFromXML( DOMElement &element ) = 0;
-
-        // uvolneni pameti po slozeni objektu, tj. lze jedine po AssemblyBD
+        //! This method parse DOMElement, finds proper DOMNode and fills binded data accordingly
+        virtual void AssemblyComponentsFromXML( DOMElement &element ) = 0;
+
+        //! A method for releasing memory allocated within the 'AssemblyComponentsFromXML()' method
         virtual void ReleaseMemory() {}
 
-        // vrati bool, pokud se povedlo rozebrat a naplnit element
-        // nebude tu nahodou jeste ten help - string??
-        virtual bool DisassamblyToXML( DOMElement &element ) = 0;               
-};
-
+        //! This method reads binded data, fill them into a new DOMNode, which then 
+        //! appends to the passed DOMElement
+        virtual bool DisassemblyComponentsToXML( DOMElement &element ) = 0;             
+};
+
+/*!
+@brief Abstract class declaring general properties of a frame for data binding 
+*/
 class Attribute 
 {               
 private:
-        // okomentovat, ze musi byt prvni
+        //! This private attribute has to be declared as the first attribute in the class.
+        //! Only this way we can be sure it's constructor is called as the first
+        //! and thus Xerces is initialized properly and right on time
         AssertXercesIsAlive dummy;
 
+        //! an attribute name
         const XMLCh* const transcodedAttributeName;
 
 public:
+        //! Default constructor fixing a name of the related attribute
         Attribute( string attributeName );
 
         ~Attribute();
 
-        // nacpe na prislusne pointery, kdyztak da NULL
+        //! This method parse DOMElement, finds proper attribute and returns its value
         string& Get( DOMElement &element ) const;
 
+        //! This method adds the passed string as an new attribute into the passed DOMElement
         void Set( DOMElement &element, const string &str ) const;       
 
+        //! Static member, an instance related to an attribute named 'help'
         static const Attribute help;
 
+        //! Static member, a constant instance related to an attribute named 'type'
         static const Attribute type;
 
+        //! Static member, a constant instance related to the attribute named 'value'
         static const Attribute value;
 };
@@ -120 +159 @@
 
 /*!
-@brief UserInfo class is for internal purposes only. Use CompoundUserInfo<T> instead.
-
-The raison d'etre of this class is to allow pointers to (the main part of) 
-CompoundUserInfo<T> objects even for different generic types.
+@brief UserInfo is an abstract is for internal purposes only. Use CompoundUserInfo<T> or ValuedUserInfo<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 'Assembly' and 'Disassembly'.
 */
 class UserInfo : protected BindingFrame
 {
 private:
+        //! just a typedef shortuct for a constant pointer to UserInfo
         typedef UserInfo* const pUserInfo;
 
-        // immediately initialized map..!!
+        //! 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
         {
@@ -137 +181 @@
                 typedef map< const string, pUserInfo > MappedString2UI;
 
+                //! immediately initialized instance of type MappedString2UI
                 static MappedString2UI& privateMap();
 
         public:
+                //! add a pair key-userinfo into the internal map
                 static void Add( string key, pUserInfo pInstance );
 
+                //! search for an userinfo related to the passed key within the internal map
                 static pUserInfo Retrieve( string key );
         };
                                 
+        //! internal method assembling a typeless instance from components obtained by the 'AssemblyComponentsFromXML()' method
         virtual void* AssemblyTypelessInstance() = 0;
         
+        //! internal method disassembling a typeless instance to components which are processed by the 'DisassemblyComponentsToXML()' method
         virtual bool DisassemblyTypelessInstance(void* pInstance) = 0;
 
+        //! an user-friendly type name
         const string userFriendlyTypeName;
 
+        //! a type name obtained by RTTI
         const string typeNameByRTTI;
 
 protected:
 
-        //! The only constructor which fills both the transcodedTypeName and the help attribute
+        //! default constructor 
         UserInfo( const string& userFriendlyTypeName, const string& typeNameByRTTI )
-                : userFriendlyTypeName ( userFriendlyTypeName ), typeNameByRTTI( typeNameByRTTI )
+                : userFriendlyTypeName ( removeSpaces( userFriendlyTypeName ) ), 
+                  typeNameByRTTI( typeNameByRTTI )
         {       
                 StringToUIMap::Add( userFriendlyTypeName, this );
-                // we do not care which name it is, therfore we have common map,
-                // and it is no use to pass the same string again
+
                 if( userFriendlyTypeName != typeNameByRTTI )
+                        // we have a common map for both groups of names, 
+                        // therefore, it is no use to add the same pair again
                         StringToUIMap::Add( typeNameByRTTI, this );
         }
 
 public: 
-        //! returns object of templated type filled with data stored in this CompoundUserInfo instance
-        // NULL if error.. TODO nekam dat error message..!
+        //! This methods tries to assembly a new instance of type T (or some of its descendant types)
+        //! according to a data stored in a DOMNode named tagName within a child nodes of the passed element.
+        //! If an error occurs, it returns a NULL pointer.
         template<class T>
         static T* Assembly( DOMElement &element, const string tagName )
@@ -175 +229 @@
                 XMLString::upperCase( transcodedTagName );
 
-
                 DOMNodeList* const nodeList = element.getElementsByTagName( transcodedTagName );
                 XMLString::release( (XMLCh**)&transcodedTagName );
                 if( !nodeList || nodeList->getLength() == 0 )
                 {
-                        cerr << "There is not any tag named """ << tagName << """ in the passed DOM element of a XML docmument!";
+                        cerr << "Warning: there is not any tag named """ << tagName << """ in the passed DOM element of a XML docmument!";
                         return NULL;
                 }
@@ -186 +239 @@
                 if( nodeList->getLength() > 1 )
                 {
-                        cerr << "There is to many elements named """ << tagName << """ in the passed DOM element of a XML docmument. But the tag name has to be unique!";
+                        cerr << "Warning: there is to many elements named """ << tagName << """ in the passed DOM element of a XML docmument. But the tag name has to be unique!";
                         return NULL;
                 }
 
-                // TAKZE MAME V RUCE ELEMENT SE JMENEM "tagName"
+                // this time we hold an element with the same name as the tagName is
                 DOMElement* pTheOnlyElement = (DOMElement*) nodeList->item(0);
 
-                // TED MAME V RUCE JMENO TYPU Z ATRIBUTU TYPE
+                // we get a velue stored in the "type" attribute 
                 string userFriendlyTypeName = Attribute::type.Get( *pTheOnlyElement );
         
-                // A TED PRISLUSNE UI
+                // and finally we find a UserInfo related to this type
                 pUserInfo pRelatedUI = StringToUIMap::Retrieve( userFriendlyTypeName );
                 if( !pRelatedUI )
                 {
-                        cerr << "There is not any UserInfo related to type named """ << userFriendlyTypeName << """, instance assembling terminated!";
+                        cerr << "Warning: there is not any UserInfo related to type named """ << userFriendlyTypeName << """, instance assembling terminated!";
                         return NULL;
                 }
 
-                pRelatedUI->AssemblyFromXML( *pTheOnlyElement );                
+                // prepare all components necessary for an instance assembling
+                pRelatedUI->AssemblyComponentsFromXML( *pTheOnlyElement );              
+
+                // instance assembling 
                 void* pTypelessInstance = pRelatedUI->AssemblyTypelessInstance();
+
+                // cleaning up
                 pRelatedUI->ReleaseMemory();
 
                 if( pTypelessInstance == NULL )
                 {
-                        // TODO lepe specifikovat
-                        cerr << "Unknown error, instance assembling terminated!";
+                        cerr << "Warning: there was some error when parsing a XML document, instance assembling terminated!";
                         return NULL;
                 }
@@ -218 +275 @@
                 try
                 {
-                        // typova kontrola "do it yourself":)
+                        // a "do it yourself" type check:)
                         pInstance = (T*) pTypelessInstance;
                         string resultingTypeNameByRTTI = typeid( *pInstance ).name();
                         if( resultingTypeNameByRTTI != pRelatedUI->typeNameByRTTI )
-                        {
-                                cerr << "Fatal error, UserInfo related to type """ << userFriendlyTypeName << """ have just returned instance of a different type!";
-                                return NULL; // TODO hlaska OK??
-                        }
+                                pInstance = NULL;
                 }
                 catch(...)
                 {
-                        pInstance = NULL; // TODO chybovou hlasku
+                        pInstance = NULL;
                 }               
+                if( pInstance == NULL )
+                        cerr << "Warning: UserInfo related to type """ << userFriendlyTypeName << """ have just returned instance of a different type! Instance assembling terminated!";
 
                 return pInstance;
         }       
 
+        //! This methods tries to disassembly an instance of type T (or some of its descendant types)
+        //! and build DOM tree accordingly. Then, it creates a new DOMNode named according tagName
+        //! and connecti it to the passed DOMElement as a new child node (with a help attribute filled).
         template<class T>
         static bool Disassembly( T& instance, DOMElement &element, const string tagName, const string help)
@@ -253 +312 @@
                 Attribute::type.Set( *pCreatedElement, pRelatedUI->userFriendlyTypeName );              
                 Attribute::help.Set( *pCreatedElement, help );
-
-                // NASMERUJE UKAZATELE BindingFrames.. rozloz na pointery.. 
+                
+                // disassembly instance itself into its components
                 bool result =  pRelatedUI->DisassemblyTypelessInstance( (void*) &instance );
                 if( result )
-                        result = pRelatedUI->DisassamblyToXML( *pCreatedElement );              
+                        // disassembly all components of an instance    
+                        result = pRelatedUI->DisassemblyComponentsToXML( *pCreatedElement );            
                 return result;
         }       
 
+        //! This methods tries to disassembly an instance of type T (or some of its descendant types)
+        //! and build DOM tree accordingly. Then, it creates a new DOMNode named according tagName
+        //! and connecti it to the passed DOMElement as a new child node.
         template<class T>
         static bool Disassembly( T &instance, DOMElement &element, const string tagName )
@@ -268 +331 @@
 };
 
+/*!
+@brief TypeUserInfo is still an abstract class, but contrary to the UserInfo class it is already 
+templated. It serves as a bridge to non-abstract classes CompoundUserInfo<T> or ValuedUserInfo<T>.
+
+There are two important features of this class. The first is a primitive mechanism bounding 
+typeless methods DisassemblyTypelessInstance, resp. AssemblyTypelessInstance, to their typed 
+virtual versions DisassemblyInstance, resp. AssemblyInstance. And the other is the only public 
+attribute of this class, called 'instance', which is to be filled by the only instance of this 
+class. Indeed, it is not  possible to create any other instance outside this class (or its 
+descendant classes), as the constructor is intentionally protected.
+*/
 template<typename T> class TypedUserInfo : public UserInfo
 {
@@ -289 +363 @@
         }
 
+        //! abstract method assembling a typed instance from components obtained by the 'AssemblyComponentsFromXML()' method
         virtual T* AssemblyInstance() = 0;
 
+        //! abstract method disassembling a typed instance to components which are processed by the 'DisassemblyComponentsToXML()' method
         virtual bool DisassemblyInstance(T& instance) = 0;
 
 protected:
 
-        //! The only constructor which fills 
+        //! default constructor, which is intentionally declared as protected
         TypedUserInfo<T>( const string &userFriendlyTypeName) 
                 : UserInfo( userFriendlyTypeName, typeid(T).name() ) 
         {       
+
         };
 
-        //! Destructor
+        //! destructor
         ~TypedUserInfo<T>()
         {
@@ -307 +384 @@
 
 public:
+        //! the only instance of this class (each type T has its own instance)
+        //! which is used as a factory for processing related userinfos
         static const TypedUserInfo<T>& instance;
-
 };
 
 
 /*!
-@brief The main user info template class
-
-You should derive this class whenever you need new CompoundUserInfo.
+@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).
+
+To bind some inner element to its own userinfo class, and also to automate its assembling and 
+disassembling, it is necessary to create a instance of an inner templated class BindedElement<T>.
+Those attributes have to be initialized in constructor of a new compound userinfo this way:
+
+\code
+class BikeUI: public CompoundUserInfo<Bike>
+{
+private:
+        BindedElement<int> year; 
+        BindedElement<bool> lights; 
+        BindedElement<string> manufacturer; 
+public:
+        BikeUI()
+                :CompoundUserInfo<Bike>("bike"),
+                year( this, "year", 0 ),
+                lights( this, "electric lights", false ), 
+                manufacturer( this, "manufacturer", "unknown")
+        {
+        }
+
+        ...
+}
+\endcode
 */
 template<typename T> class CompoundUserInfo : public TypedUserInfo<T>
 {
 private:
-        //! Mapped elements, i.e., descendant html tags
+        //! Elements binding inner XML tags to related userinfos
         vector<BindingFrame*> bindedElements;
 
 protected:
+
+        /*!
+        @brief Templated class binding inner element with its XML tag and automating data transfers
+        in both directions.
+        */
         template<typename U> class BindedElement: public BindingFrame
         {
@@ -335 +442 @@
                 const U defaultValue;
                 
+ 
         public:
                 U value;
 
                 BindedElement<U>( CompoundUserInfo<T> *parent, string name, U defaultValue, string help ) 
-                        : name( name), help(help), defaultValue( defaultValue )
+                        : name( removeSpaces( name )), help(help), defaultValue( defaultValue )
                 {
                         parent->bindedElements.push_back( this );
@@ -347 +455 @@
 
                 BindedElement<U>( CompoundUserInfo<T> *parent, string name, U defaultValue ) 
-                        : name( name), help(""), defaultValue( defaultValue ), value( defaultValue)
+                        : name( removeSpaces( name )), help(""), defaultValue( defaultValue ), value( defaultValue)
                 {
                         parent->bindedElements.push_back( this );
@@ -358 +466 @@
                 }
 
-                void AssemblyFromXML( DOMElement &element )
+                void AssemblyComponentsFromXML( DOMElement &element )
                 {
                         pValue = UserInfo::Assembly<U>( element, name );
@@ -370 +478 @@
                 }
 
-                bool DisassamblyToXML( DOMElement &element )
+                bool DisassemblyComponentsToXML( DOMElement &element )
                 {
                         return UserInfo::Disassembly( value, element, name, help );
@@ -383 +491 @@
 public:
 
-        void AssemblyFromXML( DOMElement &element )
+        void AssemblyComponentsFromXML( DOMElement &element )
         {
                 for( unsigned int ind = 0; ind < bindedElements.size(); ind++ )
-                        bindedElements[ind]->AssemblyFromXML( element );
+                        bindedElements[ind]->AssemblyComponentsFromXML( element );
         }
 
@@ -395 +503 @@
         }
 
-        bool DisassamblyToXML( DOMElement &element )
+        bool DisassemblyComponentsToXML( DOMElement &element )
         {
                 for( unsigned int ind = 0; ind < bindedElements.size(); ind++ )
-                        if( !bindedElements[ind]->DisassamblyToXML( element ) )
+                        if( !bindedElements[ind]->DisassemblyComponentsToXML( element ) )
                                 return false;
                 return true;
@@ -405 +513 @@
 
 
+/*!
+@brief The main userinfo template class. It should be derived whenever you need 
+a new userinfo of a class which does not contain any subelements. It is the case of
+basic classes(or types) like int, string, double, etc.
+
+The only thing left is to translate its public string attribute 'value' into a value 
+of type T and also implement conversion in the other way round. For that, an overloading
+of methods T* AssemblyInstance() /  bool DisassemblyInstance(T  &instance) is fruitful.
+See some valued userinfo below as an example.
+*/
 template<typename T> class ValuedUserInfo : public TypedUserInfo<T>
 {
@@ -418 +536 @@
 
 public:
-        // zde nemusi byt pointer
+        //! public attribute which is automatically binded to a proper DOMElement attribute
         string value;
 
-        void AssemblyFromXML( DOMElement &element )
+        void AssemblyComponentsFromXML( DOMElement &element )
         {               
                 value = Attribute::value.Get( element );
         }
 
-        bool DisassamblyToXML( DOMElement &element )
+        bool DisassemblyComponentsToXML( DOMElement &element )
         {
                 Attribute::value.Set( element, value );
@@ -433 +551 @@
 };
 
-
-// umi se pretypovat na DOMElement &element     
-// a to vzdy, save a load se muze udelat az pak!!
+/*!
+@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 disassembly some object into the new RootElement instance,
+and save it into the file this way:
+\code
+        CAudi audi;
+        RootElement root("cars.xml");
+        UserInfo::Disassembly( 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::Assembly<T>(root,"TT");
+\endcode
+*/
 class RootElement 
 {
-
-private:
-        // TODO musi byt prvni!! zkusit schvalne prehodit,
-        // za jmeno, a zarucit, ze Xerces jeste nebezi.. hraje to fakt roli??
+private:
+        //! This private attribute has to be declared as the first attribute in the class.
+        //! Only this way we can be sure it's constructor is called as the first
+        //! and thus Xerces is initialized properly and right on time
         const AssertXercesIsAlive dummy;
 
+        //! DOMDocument containing the root element this instance is associated to
         DOMDocument* pDoc;
 
@@ -451 +588 @@
         DOMImplementation *pImplementation;
 
-        //! This DOMWriter is used to export internal data into xml files
+        //! This DOMWriter is used to export internal data into xml file
         DOMWriter *pSerializer;
 
-public:
+        void Clean();
+
+public:
+        //! attach new RootElement instance to a file (typically with an XML extension)
         RootElement( char* fileName );
 
         ~RootElement();
 
-        void Clean();
-
-        //! loads root element from a file
+        //! this method loads root element and all its subnodes from the attached file
         bool Load( void ) ;
 
-        //! Save UserInfo to the file (typically with an XML extension)
+        //! this method saves all the previsoulsy attached DOMElements into the file 
         void Save ( void );
 
+        //! this operator allows to use a RootElement instance whenever a DOMElement variable is accepted
         operator DOMElement&();
 };
 
 
+//////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////// BASIC VALUED USER INFOS ///////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+class BoolUI: public ValuedUserInfo<bool>
+{
+private:
+
+        bool* AssemblyInstance()
+        {               
+                if( value == "true" )
+                        return new bool( true );
+                else if( value == "false" )
+                        return new bool( false );
+                else return NULL;
+        }
+
+        bool DisassemblyInstance(bool &instance)
+        {
+                if( instance )
+                        value = "true";
+                else
+                        value = "false";
+                return true; 
+        }
+
+public:
+
+        BoolUI()
+                : ValuedUserInfo<bool>("bool")
+        {
+        }
+};
+
+template<> const TypedUserInfo<bool>& TypedUserInfo<bool>::instance = BoolUI();
+
+
+class IntUI: public ValuedUserInfo<int>
+{
+private:
+
+        int* AssemblyInstance()
+        {
+                return new int( atoi( value.c_str()) );
+        }
+
+        bool DisassemblyInstance(int &instance)
+        {
+                char buff[30];
+                sprintf(buff, "%d", instance );
+                value = buff;
+                return true; 
+        }
+
+public:
+        IntUI():ValuedUserInfo<int>("int")
+        {
+        }
+};
+
+template<> const TypedUserInfo<int>& TypedUserInfo<int>::instance = IntUI();
+
+
+class DoubleUI: public ValuedUserInfo<double>
+{
+private:
+
+        double* AssemblyInstance()
+        {
+                return new double( atof( value.c_str()) );
+        }
+
+        bool DisassemblyInstance(double &instance)
+        {
+                char buff[30];
+                sprintf(buff, "%f", instance );
+                value = buff;
+                return true; 
+        }
+
+public:
+        DoubleUI():ValuedUserInfo<double>("double")
+        {
+        }
+};
+
+template<> const TypedUserInfo<double>& TypedUserInfo<double>::instance = DoubleUI();
+
+class StringUI: public ValuedUserInfo<string>
+{
+private:
+        string* AssemblyInstance()
+        {
+                return new string( value );
+        }
+
+        bool DisassemblyInstance(string &instance)
+        {
+                value = instance;
+                return true;
+        }
+
+public:
+        StringUI():ValuedUserInfo<string>("string")
+        {
+        }
+};
+
+template<> const TypedUserInfo<string>& TypedUserInfo<string>::instance = StringUI();
+
+
 #endif // #ifndef UI_H

tests/testUI.cpp

@@ -1 +1 @@
 #include "userinfo.h"
 
-//////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////// BASIC VALUED USER INFOS ///////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////
-
-class BoolUI: public ValuedUserInfo<bool>
-{
-private:
-
-        bool* AssemblyInstance()
-        {               
-                if( value == "true" )
-                        return new bool( true );
-                else
-                        return new bool( false );
-        }
-
-        bool DisassemblyInstance(bool &instance)
-        {
-                if( instance )
-                        value = "true";
-                else
-                        value = "false";
-                return true; 
-        }
-
-public:
-
-        BoolUI()
-                : ValuedUserInfo<bool>("bool")
-        {
-        }
-};
-
-template<> const TypedUserInfo<bool>& TypedUserInfo<bool>::instance = BoolUI();
-
-
-class IntUI: public ValuedUserInfo<int>
-{
-private:
-
-        int* AssemblyInstance()
-        {
-                return new int( atoi( value.c_str()) );
-        }
-
-        bool DisassemblyInstance(int &instance)
-        {
-                char buff[30];
-                sprintf(buff, "%d", instance );
-                value = buff;
-                return true; 
-        }
-
-public:
-        IntUI():ValuedUserInfo<int>("int")
-        {
-        }
-};
-
-template<> const TypedUserInfo<int>& TypedUserInfo<int>::instance = IntUI();
-
-
-class DoubleUI: public ValuedUserInfo<double>
-{
-private:
-
-        double* AssemblyInstance()
-        {
-                return new double( atof( value.c_str()) );
-        }
-
-        bool DisassemblyInstance(double &instance)
-        {
-                char buff[30];
-                sprintf(buff, "%f", instance );
-                value = buff;
-                return true; 
-        }
-
-public:
-        DoubleUI():ValuedUserInfo<double>("double")
-        {
-        }
-};
-
-template<> const TypedUserInfo<double>& TypedUserInfo<double>::instance = DoubleUI();
-
-class StringUI: public ValuedUserInfo<string>
-{
-private:
-        string* AssemblyInstance()
-        {
-                return new string( value );
-        }
-
-        bool DisassemblyInstance(string &instance)
-        {
-                value = instance;
-                return true;
-        }
-
-public:
-        StringUI():ValuedUserInfo<string>("string")
-        {
-        }
-};
-
-template<> const TypedUserInfo<string>& TypedUserInfo<string>::instance = StringUI();
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////// EXAMPLE CLASSES DEFINITION ////////////////////////
+////////////////////////////////////////// CLASSES DEFINITION ////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////
 class Transport
@@ -210 +102 @@
                 :CompoundUserInfo<Bike>("bike"),
                 year( this, "year", 0 ),
-                lights( this, "electric_lights", false ), // jen jedno slovo!
+                lights( this, "electric lights", false ), 
                 manufacturer( this, "manufacturer", "unknown")
         {