c++ - XercesC 2.7 が DOMWriter の取得に失敗する

Question

私はサーバーを作成していて、Java クライアントで XML を使用したいと考えていました。私は開発テストに XercesC 3.1.1 で CygWin を使用していますが、これは正常に動作します (この関数で 30000 をループしましたが、クラッシュはありませんでした)。ただし、私のターゲットマシンでは、XercesC 2.7 で HP-UX を実行しています。XercesC 実装の違いを実装するために、各バージョンを処理する個別のクラスを作成しました。

XercesC 2.7 でコードを実行しようとすると、. DOMWriter を作成しようとすると常に NULL ポインターが返され、再試行すると SIGABORT が返されます。

グーグルで何も見つからなかったので、誰かが私がここで間違っていることに光を当ててくれることを願っています。私は XercesC ソースで提供されているサンプルコードを見てきました。また、仲間のプログラマーからのいくつかの製品コードも持っていますが、実際には違いがわかりません。

少し長い SSCE を作成しようとしましたが、作成できる最短のサンプルです。

xml_serialize.h

#ifndef XML_SERIALIZE_H_
#define XML_SERIALIZE_H_

#include <string>

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/dom/DOM.hpp>
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif
#include <xercesc/util/OutOfMemoryException.hpp>

class XStr
{
public :
    // -----------------------------------------------------------------------
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
    XStr(const char* const toTranscode)
    {
        // Call the private transcoding method
        fUnicodeForm = xercesc::XMLString::transcode(toTranscode);
    }

    ~XStr()
    {
     xercesc::XMLString::release(&fUnicodeForm);
    }


    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
    const XMLCh* unicodeForm() const
    {
        return fUnicodeForm;
    }

private :
    // -----------------------------------------------------------------------
    //  Private data members
    //
    //  fUnicodeForm
    //      This is the Unicode XMLCh format of the string.
    // -----------------------------------------------------------------------
    XMLCh*   fUnicodeForm;
};

#define X(str) XStr(str).unicodeForm()

std::string fromXMLString(XMLCh *oXMLString);

class XMLSerialize
{
private:
        xercesc::DOMImplementation *mImpl;

protected:
        xercesc::DOMImplementation *getDOMImplementation(void);

public:
    XMLSerialize(void);
    virtual ~XMLSerialize(void);

public:

    /**
     * Creates an empty DOM
     */
    xercesc::DOMDocument *createDocument(const std::string &oDocumentName);

    /**
     * Parses an XML from a string.
     */
    xercesc::DOMDocument *parseDocument(const std::string &oDocumentName, std::string const &oReferenceId);

    /**
     * Serializes the document into a string
     */
    int serialize(xercesc::DOMDocument *oDocument, std::string &oXMLOut, bool bDocumentRelease = true);
};

#endif /* XML_SERIALIZE_H_ */

xml_serialize.cpp

#include <xercesc/util/XMLString.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/framework/MemBufFormatTarget.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>

#include <sstream>
#include <vector>
#include <iostream>

#include "xml_serialize.h"

int serializeEnvironment(void);
XMLSerialize *serializer = NULL;

XMLSerialize::XMLSerialize()
{
    mImpl = xercesc::DOMImplementationRegistry::getDOMImplementation(X("Core"));
}

XMLSerialize::~XMLSerialize()
{
}

xercesc::DOMDocument *XMLSerialize::createDocument(const std::string &oDocumentName)
{
    if(mImpl == NULL)
        return NULL;

    xercesc::DOMDocument *doc = mImpl->createDocument(
            0,                      // root element namespace URI.
            X(oDocumentName.c_str()),       // root element name
            0);                 // document type object (DTD).

    if(doc == NULL)
        return NULL;

    return doc;
}

int XMLSerialize::serialize(xercesc::DOMDocument *oDocument, std::string &oXMLOut, bool bDocumentRelease)
{
    int result = 0;
    XMLCh *xmlUnicode = NULL;
    char *strXML = NULL;
    xercesc::DOMWriter *serializer = NULL;

    if(mImpl == NULL)
    {
        oXMLOut = "ERROR: XercesC DOMImplementationRegistry not initialized";
        result = 1;
        goto Quit;
    }

    serializer = ((xercesc::DOMImplementationLS*)mImpl)->createDOMWriter();
    if(serializer == NULL)
    {
        oXMLOut = "ERROR: XercesC unable to instantiate a DOMWriter!";
        result = 2;
        goto Quit;
    }

    xmlUnicode = serializer->writeToString(*oDocument);
    strXML = xercesc::XMLString::transcode(xmlUnicode);
    oXMLOut = strXML;

    if(bDocumentRelease == true)
        oDocument->release();

    result = 0;

Quit:
    if(strXML != NULL)
        xercesc::XMLString::release(&strXML);

    if(xmlUnicode != NULL)
        xercesc::XMLString::release(&xmlUnicode);

    if(serializer != NULL)
        serializer->release();

    return result;
}

int serializeEnvironment(void)
{
    int errorCode = 0;
    xercesc::DOMElement *rootElem = NULL;
    xercesc::DOMElement *item = NULL;
    xercesc::DOMElement *element = NULL;
    xercesc::DOMText *nameNode = NULL;
    xercesc::DOMCDATASection *dataNode = NULL;
    std::string xml;

    try
    {
        xercesc::DOMDocument *doc = serializer->createDocument("EnvironmentList");
        if(doc == NULL)
            return 1;

        rootElem = doc->getDocumentElement();
        std::vector<std::pair<std::string, std::string> > env;
        for(int i = 0; i < 5; i++)
        {
            std::string key;
            std::string value;

            std::stringstream ss;
            ss << "KEY";
            ss << i;
            ss >> key;
            ss.clear();

            ss << "VALUE";
            ss << i;
            ss >> value;
            ss.clear();

            env.push_back(std::make_pair(key, value));
        }

        for(std::vector<std::pair<std::string, std::string> >::const_iterator it = env.begin(); it != env.end(); ++it)
        {
            std::pair<std::string, std::string>entry = *it;
            std::string name = entry.first;
            std::string value = entry.second;

            if(value.empty())
                value = "";

            item = doc->createElement(X("item"));
            rootElem->appendChild(item);

            element = doc->createElement(X("item"));
            nameNode = doc->createTextNode(X(name.c_str()));
            item->appendChild(element);
            element->appendChild(nameNode);

            element = doc->createElement(X("item"));
            dataNode = doc->createCDATASection(X(value.c_str()));
            item->appendChild(element);
            element->appendChild(dataNode);
        }

        errorCode = serializer->serialize(doc, xml);
        std::cout << xml << std::endl;

        doc->release();
        errorCode = 0;
    }
    catch (const xercesc::OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 2;
    }
    catch (const xercesc::DOMException& e)
    {
        XERCES_STD_QUALIFIER cerr << "DOMException code is:  " << e.code << XERCES_STD_QUALIFIER endl;
        errorCode = 3;
    }
    catch (...)
    {
        XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl;
        errorCode = 4;
    }

    return errorCode;
}

int main()
{
    xercesc::XMLPlatformUtils::Initialize();

   serializer = new XMLSerialize();

   int error = 0;
   for(int i = 0; i < 2; i++)
   {
    std::cout << "Serializing:" << i << " ... " << std::endl;
    if((error = serializeEnvironment()) != 0)
        std::cout << "ERROR" << error << std::endl;

    std::cout << "Done" << std::endl;
   }

    xercesc::XMLPlatformUtils::Terminate();

    return 0;
}

出力

Serializing:0 ... 
ERROR: XercesC unable to instantiate a DOMWriter!
Done
Serializing:1 ... 
aCC runtime: pure virtual function called for class "xercesc_2_7::DOMImplementationLS".
Abort(coredump)

アップデート

最終的に 2.7 を cygwin 用にコンパイルし、そこで上記のコードをテストしました。これで問題なく動作するので、HP-UX 環境に何らかの問題があるはずです。

c++ - XercesC 2.7 が DOMWriter の取得に失敗する

1 に答える 1

Related

Reference