work/git/mixpp/bdm/userinfo.h

#ifndef UI_H
#define UI_H

#include <sstream>
#include <iostream>
#include <stdio.h>
#include <string>
#include <typeinfo>
#include <map>
#include <utility>
#include <vector>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <iostream>
#include <xercesc/framework/LocalFileFormatTarget.hpp>
#include <xercesc/framework/LocalFileInputSource.hpp>
#include <xercesc/dom/DOMWriter.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>

#ifdef XERCES_CPP_NAMESPACE_USE
XERCES_CPP_NAMESPACE_USE
#endif

using std::string;
using namespace std;

class AssertXercesIsAlive
{
private:
        class XercesConnector
        {
        private:
                XercesConnector()
                {
                        // initialize the XML library
                        XMLPlatformUtils::Initialize();
                }

                ~XercesConnector()
                {
                        // terminate the XML library
                        XMLPlatformUtils::Terminate();
                }

        public:
                static void StayAlive()
                {
                        static XercesConnector xc;              
                };
        };


public:
        AssertXercesIsAlive()
        {
                XercesConnector::StayAlive();
        }
};

class BindingFrame
{
private:
        AssertXercesIsAlive dummy;

protected:
        BindingFrame();

        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: 
        virtual void AssemblyComponentsFromXML( DOMElement &element ) = 0;

        virtual void ReleaseMemory() {}

        virtual bool DisassemblyComponentsToXML( DOMElement &element ) = 0;             
};

class Attribute 
{               
private:
        AssertXercesIsAlive dummy;

        const XMLCh* const transcodedAttributeName;

public:
        Attribute( string attributeName );

        ~Attribute();

        string& Get( DOMElement &element ) const;

        void Set( DOMElement &element, const string &str ) const;       

        static const Attribute help;

        static const Attribute type;

        static const Attribute value;
};



class UserInfo : protected BindingFrame
{
private:
        typedef UserInfo* const pUserInfo;

        class StringToUIMap
        {
        private:
                typedef map< const string, pUserInfo > MappedString2UI;

                static MappedString2UI& privateMap();

        public:
                static void Add( string key, pUserInfo pInstance );

                static pUserInfo Retrieve( string key );
        };
                                
        virtual void* AssemblyTypelessInstance() = 0;
        
        virtual bool DisassemblyTypelessInstance(void* pInstance) = 0;

        const string userFriendlyTypeName;

        const string typeNameByRTTI;

protected:

        UserInfo( const string& userFriendlyTypeName, const string& typeNameByRTTI )
                : userFriendlyTypeName ( removeSpaces( userFriendlyTypeName ) ), 
                  typeNameByRTTI( typeNameByRTTI )
        {       
                StringToUIMap::Add( userFriendlyTypeName, this );

                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: 
        template<class T>
        static T* Assembly( DOMElement &element, const string tagName )
        {       
                XMLCh* transcodedTagName = XMLString::transcode( tagName.c_str() );             
                XMLString::upperCase( transcodedTagName );

                DOMNodeList* const nodeList = element.getElementsByTagName( transcodedTagName );
                XMLString::release( (XMLCh**)&transcodedTagName );
                if( !nodeList || nodeList->getLength() == 0 )
                {
                        cerr << "Warning: there is not any tag named """ << tagName << """ in the passed DOM element of a XML docmument!";
                        return NULL;
                }

                if( nodeList->getLength() > 1 )
                {
                        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;
                }

                // this time we hold an element with the same name as the tagName is
                DOMElement* pTheOnlyElement = (DOMElement*) nodeList->item(0);

                // we get a velue stored in the "type" attribute 
                string userFriendlyTypeName = Attribute::type.Get( *pTheOnlyElement );
        
                // and finally we find a UserInfo related to this type
                pUserInfo pRelatedUI = StringToUIMap::Retrieve( userFriendlyTypeName );
                if( !pRelatedUI )
                {
                        cerr << "Warning: there is not any UserInfo related to type named """ << userFriendlyTypeName << """, instance assembling terminated!";
                        return NULL;
                }

                // prepare all components necessary for an instance assembling
                pRelatedUI->AssemblyComponentsFromXML( *pTheOnlyElement );              

                // instance assembling 
                void* pTypelessInstance = pRelatedUI->AssemblyTypelessInstance();

                // cleaning up
                pRelatedUI->ReleaseMemory();

                if( pTypelessInstance == NULL )
                {
                        cerr << "Warning: there was some error when parsing a XML document, instance assembling terminated!";
                        return NULL;
                }

                T* pInstance = NULL;
                try
                {
                        // a "do it yourself" type check:)
                        pInstance = (T*) pTypelessInstance;
                        string resultingTypeNameByRTTI = typeid( *pInstance ).name();
                        if( resultingTypeNameByRTTI != pRelatedUI->typeNameByRTTI )
                                pInstance = NULL;
                }
                catch(...)
                {
                        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;
        }       

        template<class T>
        static bool Disassembly( T& instance, DOMElement &element, const string tagName, const string help)
        {       
                pUserInfo pRelatedUI = StringToUIMap::Retrieve( typeid(instance).name() );
                if( !pRelatedUI )
                        return false;

                // add a new element named according the passed tagName
                XMLCh* transcodedTagName = XMLString::transcode( tagName.c_str() );             
                XMLString::upperCase( transcodedTagName );
                DOMDocument* pDoc = element.getOwnerDocument();
                DOMElement* pCreatedElement = pDoc->createElement( transcodedTagName );         
                element.appendChild( pCreatedElement );
                XMLString::release( (XMLCh**)&transcodedTagName );
                        
                // add attributes "type" and "help"
                Attribute::type.Set( *pCreatedElement, pRelatedUI->userFriendlyTypeName );              
                Attribute::help.Set( *pCreatedElement, help );
                
                // disassembly instance itself into its components
                bool result =  pRelatedUI->DisassemblyTypelessInstance( (void*) &instance );
                if( result )
                        // disassembly all components of an instance    
                        result = pRelatedUI->DisassemblyComponentsToXML( *pCreatedElement );            
                return result;
        }       

        template<class T>
        static bool Disassembly( T &instance, DOMElement &element, const string tagName )
        {
                return Disassembly( instance, element, tagName, "" );
        }
};

template<typename T> class TypedUserInfo : public UserInfo
{
private:

        bool DisassemblyTypelessInstance(void* pInstance)
        {
                try
                {
                        return DisassemblyInstance( *(T*) pInstance );
                }
                catch (...)
                {
                        return false;
                }
        }

        void* AssemblyTypelessInstance()
        {
                return (void*) AssemblyInstance( );
        }

        virtual T* AssemblyInstance() = 0;

        virtual bool DisassemblyInstance(T& instance) = 0;

protected:

        TypedUserInfo<T>( const string &userFriendlyTypeName) 
                : UserInfo( userFriendlyTypeName, typeid(T).name() ) 
        {       

        };

        ~TypedUserInfo<T>()
        {
        }

        static const TypedUserInfo<T>& instance;
};


template<typename T> class CompoundUserInfo : public TypedUserInfo<T>
{
private:
        vector<BindingFrame*> bindedElements;

protected:

        template<typename U> class BindedElement: public BindingFrame
        {
        private:
                string name;
                string help;                            
                bool release;

                U* pValue;

                const U defaultValue;
                
 
        public:
                U value;

                BindedElement<U>( CompoundUserInfo<T> *parent, string name, U defaultValue, string help ) 
                        : name( removeSpaces( name )), help(help), defaultValue( defaultValue )
                {
                        parent->bindedElements.push_back( this );
                        pValue = NULL;
                        value = defaultValue;
                }

                BindedElement<U>( CompoundUserInfo<T> *parent, string name, U defaultValue ) 
                        : name( removeSpaces( name )), help(""), defaultValue( defaultValue ), value( defaultValue)
                {
                        parent->bindedElements.push_back( this );
                        pValue = NULL;
                        value = defaultValue;
                }

                ~BindedElement<U>()
                {
                }

                void AssemblyComponentsFromXML( DOMElement &element )
                {
                        pValue = UserInfo::Assembly<U>( element, name );
                        if( pValue ) value = *pValue;                   
                }

                void ReleaseMemory()
                {
                        if( pValue != NULL )
                                delete pValue;
                }

                bool DisassemblyComponentsToXML( DOMElement &element )
                {
                        return UserInfo::Disassembly( value, element, name, help );
                }
        };

private:

        void AssemblyComponentsFromXML( DOMElement &element )
        {
                for( unsigned int ind = 0; ind < bindedElements.size(); ind++ )
                        bindedElements[ind]->AssemblyComponentsFromXML( element );
        }

        void ReleaseMemory()
        {                       
                for( unsigned int ind = 0; ind < bindedElements.size(); ind++ )
                        bindedElements[ind]->ReleaseMemory();
        }

        bool DisassemblyComponentsToXML( DOMElement &element )
        {
                for( unsigned int ind = 0; ind < bindedElements.size(); ind++ )
                        if( !bindedElements[ind]->DisassemblyComponentsToXML( element ) )
                                return false;
                return true;
        }

protected:

        CompoundUserInfo<T>( string userFriendlyTypeName )
                : TypedUserInfo<T>( userFriendlyTypeName )
        {
        }

};


template<typename T> class ValuedUserInfo : public TypedUserInfo<T>
{
private:
        void AssemblyComponentsFromXML( DOMElement &element )
        {               
                value = Attribute::value.Get( element );
        }

        bool DisassemblyComponentsToXML( DOMElement &element )
        {
                Attribute::value.Set( element, value );
                return true;
        }

protected:
        ValuedUserInfo<T>( string userFriendlyTypeName )
                : TypedUserInfo<T>( userFriendlyTypeName )
        {
        }

        ~ValuedUserInfo<T>()
        {
        }

        string value;
};

class RootElement 
{
private:
        const AssertXercesIsAlive dummy;

        DOMDocument* pDoc;

        const XMLCh* const transcodedFileName;

        DOMImplementation *pImplementation;

        DOMWriter *pSerializer;

        void Clean();

public:
        RootElement(const char* fileName );

        ~RootElement();

        bool Load( void ) ;

        void Save ( void );

        operator DOMElement&();
};



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")
        {
        }
};


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")
        {
        }
};



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")
        {
        }
};


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")
        {
        }
};


#endif // #ifndef UI_H

---