cpfdemarshaller.cpp

机器人开源项目orocos的源代码

                if ( ln == "properties" )
                    tag_stack.push( TAG_PROPERTIES );
                else
                    if ( ln == "simple" ) 
                    {

                        tag_stack.push( TAG_SIMPLE );
                        for (unsigned int ac = 0; ac < attributes.getLength(); ++ac)
                        {
                            std::string an;
                            XMLChToStdString( attributes.getLocalName(ac), an );
                            if ( an == "name") 
                            {
                                XMLChToStdString( attributes.getValue(ac), name);
                            }
                            else if ( an == "type")
                            {
                                XMLChToStdString( attributes.getValue(ac), type);
                            }
                        }
                    }
                    else
                        if ( ln == "struct" || ln == "sequence")
                        {
                            for (unsigned int ac = 0; ac < attributes.getLength(); ++ac)
                            {
                                std::string an;
                                XMLChToStdString( attributes.getLocalName(ac), an );
                                if ( an == "name") 
                                {
                                    XMLChToStdString( attributes.getValue(ac), name);
                                }
                                else if ( an == "type") 
                                {
                                    XMLChToStdString( attributes.getValue(ac), type);
                                }
                            }

                            if ( ln == "struct" )
                                tag_stack.push( TAG_STRUCT );
                            else {
                                tag_stack.push( TAG_SEQUENCE );
                                type = "Sequence"; // override
                            }

                            Property<PropertyBag> *prop;
                            prop = new Property<PropertyBag>(name,"",PropertyBag(type));
                            
                            // take reference to bag itself !
                            bag_stack.push(std::make_pair( &(prop->value()), prop));
                        }
                        else
                                if ( ln == "description") 
                                    tag_stack.push( TAG_DESCRIPTION );
                                else
                                    if ( ln == "value"  )
                                        tag_stack.push( TAG_VALUE );
                                    else {
                                        log(Warning) << "Unrecognised XML tag :"<< ln <<": ignoring." << endlog();
                                        tag_stack.push( TAG_UNKNOWN );
                                    }
            }

            void warning( const SAXParseException& exception )
            {
                std::string warn;
                XMLChToStdString( exception.getMessage(), warn);
                Logger::log() << Logger::Warning << "SAX2CPFHandler Parsing: " << warn <<Logger::nl;
                if ( exception.getPublicId() )
                    {
                        XMLChToStdString( exception.getPublicId(), warn);
                        Logger::log() << " At entity "<< warn <<Logger::nl;
                    }
                Logger::log() << " Column "<< exception.getColumnNumber()<< " Line " <<exception.getLineNumber()<<Logger::endl;
                // to not throw.
            }

            void error( const SAXParseException& exception )
            {
                throw exception;
            }
            void fatalError( const SAXParseException& exception )
            {
                throw exception;
            }
            void characters( const XMLCh* const chars, const unsigned int length )
            {
                //char *ln = XMLString::transcode( chars );
                switch ( tag_stack.top() )
                {
                    case TAG_DESCRIPTION:
                        XMLChToStdString( chars, description);
                        break;

                    case TAG_VALUE:
                        XMLChToStdString( chars, value_string);
                        break;
                    case TAG_STRUCT:
                    case TAG_SIMPLE:
                    case TAG_SEQUENCE:
                    case TAG_PROPERTIES:
                    case TAG_UNKNOWN:
                        break;
                }
            }


    };

    CPFDemarshaller::CPFDemarshaller( const std::string& filename )
        : name(0), fis(0)
    {
        Logger::In in("CPFDemarshaller");
        try
            {
                XMLPlatformUtils::Initialize();
            }
        catch ( const XMLException & toCatch )
            {
                std::string error;
                XMLChToStdString(toCatch.getMessage(), error);
                Logger::log() << Logger::Error << "XML Initialization : "
                              << error << Logger::endl;
            }
        catch ( ... )
            {
                Logger::log() << Logger::Error << "XML Init: General System Exception !" << Logger::endl;
            }

        try {
            name =  XMLString::transcode( filename.c_str() );
            fis  = new LocalFileInputSource( name );
        }
        catch ( XMLException& xe )
            {
                Logger::log() << Logger::Error << "Failed to open file " <<filename << Logger::endl;
                Logger::log() << Logger::Error << xe.getMessage() << Logger::endl;
                
                fis = 0;
            }
        catch ( ... )
            {
                Logger::log() << Logger::Error << "Opening file: General System Exception !" << Logger::endl;
            }
        delete[] name;
    }

    CPFDemarshaller::~CPFDemarshaller()
    {
        delete fis;
        XMLPlatformUtils::Terminate();
    }
    
    bool CPFDemarshaller::deserialize( PropertyBag &v )
    {
        if ( fis == 0 )
            return false;

        SAX2XMLReader* parser = 0;
        try {
            XMLPlatformUtils::Initialize();
            parser = XMLReaderFactory::createXMLReader();
        }
        catch ( ... )
            {
                Logger::log() << Logger::Error << "SAX2XMLReader System Exception !" << Logger::endl;
                XMLPlatformUtils::Terminate();
                return false;
            }

        int errorCount = 0;

        Logger::In in("CPFDemarshaller");

        try
            {
                SAX2CPFHandler handler( v );
                parser->setContentHandler( &handler );
                parser->setErrorHandler( &handler );
                parser->setFeature( XMLUni::fgSAX2CoreValidation, false );
                parser->setFeature( XMLUni::fgXercesValidationErrorAsFatal, false );
                parser->setFeature( XMLUni::fgXercesContinueAfterFatalError, false );
#if 0
                parser->setFeature( XMLUni::fgXercesSchemaFullChecking, false );
                parser->setFeature( XMLUni::fgXercesDynamic, true );
                parser->setFeature( XMLUni::fgSAX2CoreNameSpaces, true );
                parser->setFeature( XMLUni::fgSAX2CoreNameSpacePrefixes, true );
                parser->setFeature( XMLUni::fgXercesSchema, false );
#endif
                // try to avoid loading the DTD mentioned in the xml file,
                // and load our own grammer.
                using namespace detail;
                parser->setFeature( XMLUni::fgXercesLoadExternalDTD, false );
                //parser->setDoValidation(true);
                int length  = XMLString::stringLen(cpf_dtd);// string length
                XMLByte* buffer = new XMLByte[length];
                memcpy( buffer, cpf_dtd, length );
                MemBufInputSource dtd(buffer, length, "internal_cpf.dtd");
                parser->loadGrammar( dtd, Grammar::DTDGrammarType );
                delete[] buffer;

                parser->parse( *fis );
                errorCount = parser->getErrorCount();
                delete parser;
                XMLPlatformUtils::Terminate();
            }
        catch ( const XMLException & toCatch )
            {
                Logger::log() << Logger::Error << "An XML parsing error occurred processing file " <<Logger::nl;
                if ( toCatch.getSrcFile() ) {
                    Logger::log() <<  toCatch.getSrcFile() << " parsing line " << toCatch.getSrcLine()<<Logger::nl ;
                }
                Logger::log()  << XMLgetString(toCatch.getMessage()) <<Logger::endl;
                delete parser;
                XMLPlatformUtils::Terminate();
                return false;
            }
        catch ( const SAXParseException & toCatch )
            {
                Logger::log() << Logger::Error << "An XML SAX parsing error occurred processing file " <<Logger::nl;
                Logger::log()  << XMLgetString(toCatch.getMessage()) <<Logger::endl;
                if ( toCatch.getPublicId() )
                    {
                        Logger::log() << " At entity "<< XMLgetString(toCatch.getPublicId()) <<Logger::nl;
                    }
                Logger::log() << " Column "<< toCatch.getColumnNumber()<< " Line " <<toCatch.getLineNumber()<<Logger::endl;
                delete parser;
                XMLPlatformUtils::Terminate();
                return false;
            }
        catch ( const SAXException & toCatch )
            {
                Logger::log() << Logger::Error << "An XML SAX exception occurred processing file " <<Logger::nl;
                Logger::log()  << XMLgetString(toCatch.getMessage()) <<Logger::endl;
                delete parser;
                XMLPlatformUtils::Terminate();
                return false;
            }
        catch ( ... )
            {
                Logger::log() << Logger::Error << "General System Exception !" << Logger::endl;
                delete parser;
                XMLPlatformUtils::Terminate();
                return false;
            }
        return true;
    }
}

#endif