work/git/mixpp/bdm/userinfo.h

#ifndef UI_H
#define UI_H

#include <sstream>
#include <iostream>
#include <stdio.h>
#include <string>
#include <map>
#include <utility>
#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 GlobalXercesConnector
{
public:
        DOMImplementation *pImplementation;
        DOMWriter *pSerializer;
        XercesDOMParser *pParser;


        GlobalXercesConnector();
        ~GlobalXercesConnector();


        static string XMLCh2str( const XMLCh* const  XMLCh_str );

        class Comparator
        {
        public:
                bool operator()( const XMLCh* const a , const XMLCh* const b) const;
        };
};

extern const GlobalXercesConnector XMLConnector;


class Attribute 
{
private:
        XMLCh* const transcodedName;

public:
        typedef map<const XMLCh* const, Attribute* const, GlobalXercesConnector::Comparator> MappedAttributes;

        Attribute( const string name );
        ~Attribute();

        virtual void Set( const string str ) = 0;
        virtual const string Get() = 0; 
        void Attach( MappedAttributes &externalAttributes);
        void FillAttribute(DOMElement &element);
};

class DoubleAttribute: public Attribute
{
public:
        double value;
        DoubleAttribute( const string name);
        void Set( const string str );
        const string Get();
};


class IntAttribute : public Attribute
{
public:
        int value;
        IntAttribute( const string name );
        void Set( const string str );
        const string Get();
};

class StringAttribute : public Attribute
{
public:
        string value;
        StringAttribute( const string name );
        void Set( const string str );
        const string Get();
};

class UserInfoCore
{
public:
        virtual void ParseElement(DOMElement *element) = 0;

        virtual void FillElement(DOMElement &element) = 0;
};

template<typename T> class UserInfo : public UserInfoCore
{
private:
        XMLCh* transcodedName;
        
        typedef map<const XMLCh* const, UserInfoCore* const, GlobalXercesConnector::Comparator> MappedElements;

protected:
        MappedElements elements;
        Attribute::MappedAttributes attributes;

public:
        StringAttribute help;

        UserInfo<T>( 
                const string name, 
                const string help_msg = "" ) 
                : help("help"),         
                transcodedName( XMLString::transcode( name.c_str() ) )
        {       
                XMLString::upperCase( transcodedName );
                help.Attach( attributes );
                help.value = help_msg;
        };
        ~UserInfo<T>()
        {
                XMLString::release( (XMLCh**)&transcodedName );
        }

        virtual T* build(void) = 0;

        void Save ( char* fileName )
        {
                XMLCh* transcodedFileName = XMLString::transcode( fileName );
                LocalFileFormatTarget outputTarget( transcodedFileName );
                XMLString::release( &transcodedFileName );

                DOMDocument* pDoc = XMLConnector.pImplementation->createDocument( 
                        XMLString::transcode( "M3K USER INFO" ), 
                        XMLString::transcode( "ROOT" ), NULL );
                DOMElement *pRoot = pDoc->getDocumentElement();

                FillElement( *pRoot );

                XMLConnector.pSerializer->writeNode( &outputTarget, *pDoc);
                delete pDoc;
        }       
        void Load ( char* fileName ) 
        {
                bool bFailed = false;

                try
                {
                        XMLCh* transcodedFileName = XMLString::transcode( fileName ) ;
                        const LocalFileInputSource inputSource( transcodedFileName );           
                        XMLString::release( &transcodedFileName );

                        XMLConnector.pParser->parse( inputSource );
                        bFailed = ( XMLConnector.pParser->getErrorCount() != 0 );
                }
                catch (...)
                {
                        bFailed = true;
                }

                if( !bFailed)
                {
                        DOMDocument *pDoc = XMLConnector.pParser->getDocument();                
                        DOMElement *pRoot = pDoc->getDocumentElement();
                        bFailed = true;
                        for( DOMNode* node = pRoot->getFirstChild(); node != NULL; node = node->getNextSibling() )
                                if( node->getNodeType() == DOMNode::ELEMENT_NODE )
                                {
                                        ParseElement( (DOMElement*) node );
                                        bFailed = false;
                                        break;
                                }
                }

                if( bFailed )
                {
                        // exception?!
                }               
        }
        void Attach( MappedElements &externalElements)
        {
                pair<const XMLCh* const, UserInfoCore* const> newPair( transcodedName, this );
                externalElements.insert(newPair);
        }
        
        void ParseElement(DOMElement *element) 
        {
                DOMNodeList* nodeList = element->getChildNodes();
                if( nodeList )
                        for( int i = 0; i < nodeList->getLength(); i++ )
                        {
                                DOMNode* node = nodeList->item(i);
                                if( node->getNodeType() == DOMNode::ELEMENT_NODE )
                                {
                                        DOMElement* childElement = (DOMElement*) node;
                                        MappedElements::const_iterator iter = elements.find( childElement->getTagName() );

                                        if( iter != elements.end())
                                                iter->second->ParseElement( childElement );
                                }
                        }
                        
                DOMNamedNodeMap* nodeMap = element->getAttributes();
                if( nodeMap )
                        for( int i = 0; i < nodeMap->getLength(); i++ )
                        {
                                DOMNode* node = nodeMap->item(i);
                                if( node->getNodeType() == DOMNode::ATTRIBUTE_NODE )
                                {
                                        DOMAttr* attribute = (DOMAttr*) node;
                                        Attribute::MappedAttributes::const_iterator iter = attributes.find( attribute->getName() );

                                        if( iter != attributes.end())
                                        {
                                                string attributeValue = GlobalXercesConnector::XMLCh2str( attribute->getValue() );
                                                iter->second->Set( attributeValue );
                                        }
                                }
                        }
        }
        
        void FillElement(DOMElement &element)
        {
                DOMDocument* pDoc = element.getOwnerDocument();

                DOMElement* pHead = pDoc->createElement( transcodedName );              
                element.appendChild( pHead );

                for( MappedElements::const_iterator iter = elements.begin(); iter != elements.end(); iter++)
                        iter->second->FillElement( *pHead );

                for( Attribute::MappedAttributes::iterator iter = attributes.begin(); iter != attributes.end(); iter++)
                        iter->second->FillAttribute( *pHead );
        }
};

#endif // #ifndef UI_H

---