Changeset 122

Timestamp:

06/19/08 22:20:11 (17 years ago)

Author:

mido

Message:

prvni verze UserInfa?<T>

Files:

• bdm/userinfo.cpp (modified) (1 diff)
• bdm/userinfo.h (modified) (2 diffs)
• tests/CMakeLists.txt (modified) (1 diff)
• tests/testUI.cpp (modified) (1 diff)

bdm/userinfo.cpp

@@ -11 +11 @@
 //
 
-#include <itpp/itbase.h>
 #include "userinfo.h"
+
+GlobalXercesConnector::GlobalXercesConnector()
+{
+        // initialize the XML library
+        XMLPlatformUtils::Initialize();
+
+        // get a serializer, an instance of DOMWriter (the "LS" stands for load-save).
+        pImplementation = DOMImplementationRegistry::getDOMImplementation(L"LS");
+
+        pSerializer = ( (DOMImplementationLS*)pImplementation )->createDOMWriter();
+        // set user specified end of line sequence and output encoding
+        pSerializer->setNewLine( L"\n" );
+        // optionally, set the format-pretty-print feature
+        if (pSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true))
+                pSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
+
+        pParser = new XercesDOMParser;  
+        pParser->setValidationScheme(XercesDOMParser::Val_Auto);
+        pParser->setDoNamespaces(false);
+        pParser->setDoSchema(false);
+}
+
+GlobalXercesConnector::~GlobalXercesConnector()
+{
+        delete pParser; 
+        delete pSerializer;
+
+        // terminate the XML library
+        XMLPlatformUtils::Terminate();
+}
+
+string GlobalXercesConnector::XMLCh2str( const XMLCh* const  XMLCh_str )
+{
+        char *local = XMLString::transcode( XMLCh_str );
+        string res = local;             
+        XMLString::release( &local );
+        return res;
+}
+
+bool GlobalXercesConnector::Comparator::operator()( const XMLCh* const a , const XMLCh* const b) const
+{
+        return ( XMLString::compareString(a,b) > 0);
+}       
+
+const GlobalXercesConnector XMLConnector;
+
+//////////////////////
+
+Attribute::Attribute( const string name ) 
+        :       transcodedName ( XMLString::transcode( name.c_str() ) ) 
+{       
+        XMLString::lowerCase( transcodedName );
+}
+
+Attribute::~Attribute() 
+{                
+        XMLString::release( (XMLCh**)&transcodedName );
+}
+
+void Attribute::Attach( MappedAttributes &externalAttributes)
+{
+        pair<const XMLCh* const, Attribute* const> newPair( transcodedName, this );
+        externalAttributes.insert(newPair);
+}
+
+void Attribute::FillAttribute(DOMElement &element)
+{
+        DOMDocument* pDoc = element.getOwnerDocument();
+        DOMAttr* pAttribute = pDoc->createAttribute( transcodedName );
+
+        const string attributeValue = Get();
+        XMLCh* transcodedValue = XMLString::transcode( attributeValue.c_str() ); 
+        pAttribute->setValue( transcodedValue );
+        XMLString::release( &transcodedValue );
+
+        element.setAttributeNode(pAttribute);                   
+}
+
+DoubleAttribute::DoubleAttribute( const string name) 
+        : Attribute( name )
+{
+        value = 0;
+}
+
+void DoubleAttribute::Set( const string str )
+{
+        value = atof( str.c_str() );
+}
+
+const string DoubleAttribute::Get()
+{ 
+        char buffer[50];
+        sprintf( buffer, "%f", value );
+        return string( buffer );
+}   
+
+
+/*!
+@brief User Info base class
+
+This class is used to store information about parameters of an object. It support loading and saving of the information and, potentially, interaction with the user.
+*/
+IntAttribute::IntAttribute( const string name ) 
+        : Attribute( name )
+{
+        value = 0;
+}
+
+void IntAttribute::Set( const string str )
+{
+        value = atoi( str.c_str() );
+}
+
+const string IntAttribute::Get()
+{ 
+        char buffer[50];
+        sprintf( buffer, "%d", value );
+        return string( buffer );
+}   
+
+
+/*!
+@brief User Info base class
+
+This class is used to store information about parameters of an object. It support loading and saving of the information and, potentially, interaction with the user.
+*/
+StringAttribute::StringAttribute( const string name ) 
+        : Attribute( name ),
+        value("")
+{
+}
+
+void StringAttribute::Set( const string str )
+{
+        value = str.c_str();
+}
+
+const string StringAttribute::Get()
+{ 
+        return value;           
+}   
+
+

bdm/userinfo.h

@@ -1 @@
-//
-// C++ Interface: userinfo
-//
-// Description:
-//
-//
-// Author: smidl <smidl@utia.cas.cz>, (C) 2008
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
-#include <itpp/itbase.h>
-#include <itpp/base/mat.h>
-
-using std::cout;
-using std::endl;
+#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;
+
+
+/*!
+@brief Xerces interface class
+
+This class is used to interact with the Xerces library.
+*/
+class GlobalXercesConnector
+{
+public:
+        //! DOMImplementation is a base class for the all DOM oparations
+        DOMImplementation *pImplementation;
+        //! This DOMWriter is used to export internal data into xml files
+        DOMWriter *pSerializer;
+        //! This DOMWriter is used to import external data from xml files
+        XercesDOMParser *pParser;
+
+
+        //!default constructor
+        GlobalXercesConnector();
+        //!destructor
+        ~GlobalXercesConnector();
+
+
+        //! function transcodes Xerces' XMLCh-based strings into C++ strings
+        static string XMLCh2str( const XMLCh* const  XMLCh_str );
+
+        class Comparator
+        {
+        public:
+                //! operator compares two XMLCh strings and wheather the first is alphabethically higher
+                bool operator()( const XMLCh* const a , const XMLCh* const b) const;
+        };
+};
+
+//! The only global instance of the GlobalXercesConnector class
+extern const GlobalXercesConnector XMLConnector;
+
 
 /*!
@@ -22 +67 @@
 This class is used to store information about parameters of an object. It support loading and saving of the information and, potentially, interaction with the user.
 */
-class uibase {
+
+class Attribute 
+{
+private:
+        //! Name which identifies the attribute among others related to the same XML-tag, 
+        //! must be unique within its context!
+        XMLCh* const transcodedName;
+
+public:
+        //! Type definition of mapping which transforms names to the related attributes 
+        typedef map<const XMLCh* const, Attribute* const, GlobalXercesConnector::Comparator> MappedAttributes;
+
+        //! The only constructor which fills the transcodedName attribute
+        Attribute( const string name );
+        //! Destructor
+        ~Attribute();
+
+        //! Set accessor to this attribute converting input string into a properly-typed value 
+        virtual void Set( const string str ) = 0;
+        //! Get accessor converting stored value into a string
+        virtual const string Get() = 0; 
+        //! This method is the key method to connect the attribute to the related UI element
+        void Attach( MappedAttributes &externalAttributes);
+        //! This method add and DOMAttribute node to the DOMElement passed as an argument
+        void FillAttribute(DOMElement &element);
+};
+
+/*!
+@brief Class encapsulating all the necessary stuff to work with the double attribute 
+*/
+class DoubleAttribute: public Attribute
+{
+public:
+        double value;
+        DoubleAttribute( const string name);
+        void Set( const string str );
+        const string Get();
+};
+
+
+/*!
+@brief Class encapsulating all the necessary stuff to work with an int attribute 
+*/
+class IntAttribute : public Attribute
+{
+public:
+        int value;
+        IntAttribute( const string name );
+        void Set( const string str );
+        const string Get();
+};
+
+/*!
+@brief Class encapsulating all the necessary stuff to work with a string attribute 
+*/
+class StringAttribute : public Attribute
+{
+public:
+        string value;
+        StringAttribute( const string name );
+        void Set( const string str );
+        const string Get();
+};
+
+/*!
+@brief UserInfoCore class is for internal purposes only. Use UserInfo<T> instead.
+
+The raison d'etre of this class is to allow pointers to (the main part of) 
+UserInfo<T> objects even for different generic types.
+*/
+class UserInfoCore
+{
+public:
+        //! Fills internal attributes and descendant elements according DOMElement
+        virtual void ParseElement(DOMElement *element) = 0;
+
+        //! Fills DOMElement according internal attributes and descendant elements
+        virtual void FillElement(DOMElement &element) = 0;
+};
+
+/*!
+@brief The main user info template class
+
+You should derive this class whenever you need new UserInfo.
+*/
+template<typename T> class UserInfo : public UserInfoCore
+{
+private:
+        //! Name which identifies the element among others related to the same XML-tag, 
+        //! must be unique within its context!
+        XMLCh* transcodedName;
+        
+        //! Type definition of mapping which transforms names to the related elements
+        typedef map<const XMLCh* const, UserInfoCore* const, GlobalXercesConnector::Comparator> MappedElements;
+
 protected:
-        //! String identifier of a field
-        string name;
-        //! Explanation for a user what the field means
-        string help;
-        //! Possible parent of the userinfo
-        uibase* parent;
-        //! Indentation level, i.e. number of parents
-        int ilevel;
-public:
-//!Default constructor
-        uibase ( string com = "Abstract class, please ignore!", uibase* par=NULL ) :name ( com ),help ( "" ),parent ( par ) {
-                if ( parent!=NULL ) {ilevel=parent->get_level() +1;}
-                else {ilevel =0;}
-        }
-
-//! returns a summary of its contents (used in dialogs)
-        virtual void getsummary ( std::string &S ) {};
-
-//! interaction with the user
-        virtual void askuser() {};
-
-//! test if the info is valid
-        virtual bool isvalid() {return true;}
-        //! for future use
-        virtual ~uibase() {};
-        //! Save to file
-        virtual void save ( std::ostream &os ) {
-                os.width(ilevel);
-                os.fill(' ');
-                os<<"#"<<help<<endl;
-                os.width(ilevel);
-                os.fill(' ');
-                os<<name<<" = ";
+        //! MappiLength of the output vector
+        MappedElements elements;
+        //! Length of the output vector
+        Attribute::MappedAttributes attributes;
+
+public:
+        //! Explanation for an user is the only obligatory attribute
+        StringAttribute help;
+
+        //! The only constructor which fills both the transcodedName and the help attribute
+        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;
         };
-        //! load from file
-        virtual void load ( std::istream &is ) {
-                char tmp[200];
-                is.ignore ( ilevel+1,'#' ); // +1 is for #
-                is.getline ( tmp,200 );help=tmp;
-                is.ignore ( ilevel,'\0' );
-                is.getline ( tmp,200,'=' ); name=tmp;
-        };
+        //! Destructor
+        ~UserInfo<T>()
+        {
+                XMLString::release( (XMLCh**)&transcodedName );
+        }
+
+        //! returns object of templated type filled with data stored in this UserInfo instance
+        virtual T* build(void) = 0;
+
+        //! Save UserInfo to the file (typically with an XML extension)
+        void Save ( char* fileName )
+        {
+                XMLCh* transcodedFileName = XMLString::transcode( fileName );
+                LocalFileFormatTarget outputTarget( transcodedFileName );
+                XMLString::release( &transcodedFileName );
+
+                DOMDocument* pDoc = XMLConnector.pImplementation->createDocument( L"M3K USER INFO", L"ROOT", NULL );
+                DOMElement *pRoot = pDoc->getDocumentElement();
+
+                FillElement( *pRoot );
+
+                XMLConnector.pSerializer->writeNode( &outputTarget, *pDoc);
+                delete pDoc;
+        }       
+        //! Load UserInfo from the file (typically with an XML extension)
+        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?!
+                }               
+        }
+        //! This method is the key method to connect the element to its parent UI element
+        void Attach( MappedElements &externalElements)
+        {
+                pair<const XMLCh* const, UserInfoCore* const> newPair( transcodedName, this );
+                externalElements.insert(newPair);
+        }
         
-        //!access function
-        int get_level(){return ilevel;}
-};
-
-//! User info for scalars
-template<class T>
-class uiscalar : public uibase {
-protected:
-        //! Value
-        T N;
-public:
-//!Default constructor
-        uiscalar ( std::string com, uibase* par =NULL) :uibase ( com,par ) {N=T ( 0 );};
-
-        void getsummary ( std::string &S ) {S="Scalar";};
-
-        void askuser () {};
-
-        void save ( std::ostream &os ) {uibase::save ( os );os<<N<<endl;}
-        void load ( std::istream &is ) {uibase::load ( is );is>>N;}
-        //! for future use
-        ~uiscalar() {};
-
-        //! access function
-        void set_value ( T N0 ) {N=N0;}
-};
-
-//! User info for strings
-class uistring : public uibase {
-protected:
-        //! Values
-        std::string S;
-public:
-        void getsummary ( std::string &S ) {S="String";};
-
-//!Default constructor
-        uistring ( std::string com , uibase* par=NULL) :uibase ( com,par ) {}
-
-        void askuser () {};
-
-        void save ( std::ostream &os ) {uibase::save ( os );os<<S<<endl;}
-        void load ( std::istream &is ) {uibase::load ( is );is>>S;}
-
-        ~uistring() {};
-        //! access function
-        void set_value ( std::string S0 ) {S=S0;}
-};
-
-//! User info for vectors
-template<class T>
-class uivector : public uibase {
-protected:
-        //! Value
-        itpp::Vec<T> V;
-public:
-        void getsummary ( std::string &S ) { S="Vector of length "+ V.length();};
-
-//!Default constructor
-        uivector ( std::string com, uibase* par=NULL ) :uibase ( com,par ) {};
-
-        void askuser () {};
-
-        void save ( std::ostream &os ) {uibase::save ( os );os<<V<<endl;;}
-        void load ( std::istream &is ) {uibase::load ( is );is>>V;}
-
-        //! access function
-        void set_value ( itpp::Vec<T> V0 ) {V=V0;}
-
-};
-
-//! User info for matrices
-template<class T>
-class uimatrix : public uibase {
-protected:
-        //! Value
-        itpp::Mat<T> M;
-
-public:
-        //!Default constructor
-        uimatrix ( std::string com, uibase* par=NULL ) :uibase ( com,par ) {}
-
-        void getsummary ( std::string &S ) { S="Matrix ";};
-
-        void askuser () {};
-
-        void save ( std::ostream &os ) {uibase::save ( os );os<<M<<endl;}
-        void load ( std::istream &is ) {uibase::load ( is );is>>M;}
-
-        //! access function
-        void set_value ( itpp::Mat<T> M0 ) {M=M0;}
-};
-
-
-typedef uimatrix<double> uimat;
-typedef uimatrix<int> uiimat;
-
-typedef uivector<double> uivec;
-typedef uivector<int> uiivec;
-
+        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

tests/CMakeLists.txt

@@ -50 +50 @@
 target_link_libraries (testKF_QR ${BdmLibs})
 target_link_libraries (testKF_QRexh ${BdmLibs})
-target_link_libraries (testUI ${BdmLibs})
+target_link_libraries (testUI ${BdmLibs} ${XERCES_LIBRARIES})
 
 

tests/testUI.cpp

@@ -1 @@
-#include <itpp/itbase.h>
-#include <fstream>
 #include "userinfo.h"
 
-//These lines are needed for use of cout and endl
-using namespace std;
+class Engine 
+{
+public:
+        string producer;
+        double consumption;
+
+        Engine( string producer, double consumption )
+                : producer( producer ),
+                consumption( consumption )
+        {
+        }
+};
+
+//! User info for strings
+class EngineUI : public UserInfo<Engine> 
+{
+public:
+        StringAttribute producer;
+        DoubleAttribute consumption;
+        
+        EngineUI()
+                : UserInfo( "engine", "type of engine" ),
+                producer( "producer"),
+                consumption( "consumption")
+        {
+                producer.Attach( attributes );
+                consumption.Attach( attributes );
+        }
+
+        Engine* build()
+        {               
+                return new Engine( producer.value, consumption.value );
+        }
+};
+
+
+class Car
+{
+public:
+        string color;
+        int year;
+        Engine engine;
+
+        Car( string color, int year, Engine engine)
+                : color( color ),
+                year( year ),
+                engine( engine )
+        {
+        }
+};
+
+//! User info for strings
+class CarUI : public UserInfo<Car> 
+{
+public:
+        EngineUI engine;
+
+        StringAttribute color;
+        IntAttribute year;
+
+        CarUI()
+                : UserInfo("car", "type of a car"), 
+                color( "color"), 
+                year( "year" )
+        {
+                engine.Attach( elements );
+
+                color.Attach( attributes );
+                year.Attach( attributes );
+        }
+
+        Car* build()
+        {               
+                Engine* pEng = engine.build();
+                return new Car(color.value, year.value,*pEng);
+        }
+};
+
 
 int main()
 {
-        uiscalar<double> uisc("Sc");    
-        uiscalar<double> uisc2("");     
-        uivec uiv("VEc");
-        uivec uiv2("V");
-        uistring uist("Str");
-        uistring uist2("S");
-        uimat uim("Mat");
-        uimat uim2("M");
-        
-        //SET values
-        
-        uisc.set_value(0.5);
-        uiv.set_value(itpp::vec_2(1.3,1.7));
-        uist.set_value("Wow this is cool!");
-        uim.set_value(itpp::mat_2x2(1.1,1.2,1.3,1.4));
-        
-        ofstream OF;
-        OF.open("testUI.exb");
-        uisc.save(OF);
-        uiv.save(OF);
-        uist.save(OF);
-        uim.save(OF);
-        OF.close();
-        
-        ifstream IF;
-        IF.open("testUI.exb");
-        uisc2.load(IF);
-        uiv2.load(IF);
-        uist2.load(IF);
-        uim2.load(IF);
-        IF.close();
-        
-        //Exit program:
+        CarUI car;
+
+        car.Save( "car.xml" );  
+
+/*
+        car.Load( "car.xml" );
+        Car *pDefaultCar = car.build();
+        cout << "our car has " << pDefaultCar->color << " color";
+        delete pDefaultCar;
+// */
+
+        getchar();
         return 0;
+}
 
-}