DOMPrint

最新推荐文章于 2024-11-07 23:31:23 发布

zhujun012

最新推荐文章于 2024-11-07 23:31:23 发布

阅读量450

点赞数

文章标签： permissions filter apache express serialization file

本文链接：https://blog.csdn.net/zhujun012/article/details/6137279

版权

//DOMPrint.cpp

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/*
* $Id: DOMPrint.cpp 568078 2007-08-21 11:43:25Z amassari $
*/

// ---------------------------------------------------------------------------
// This sample program invokes the XercesDOMParser to build a DOM tree for
// the specified input file. It then invokes DOMWriter::writeNode() to
// serialize the resultant DOM tree back to XML stream.
//
// Note:
// Application needs to provide its own implementation of
//     DOMErrorHandler (in this sample, the DOMPrintErrorHandler),
//     if it would like to receive notification from the serializer
//     in the case any error occurs during the serialization.
//
// Application needs to provide its own implementation of
//     DOMWriterFilter (in this sample, the DOMPrintFilter),
//     if it would like to filter out certain part of the DOM
//     representation, but must be aware that thus may render the
//     resultant XML stream invalid.
//
// Application may choose any combination of characters as the
//     end of line sequence to be used in the resultant XML stream,
//     but must be aware that thus may render the resultant XML
//     stream ill formed.
//
// Application may choose a particular encoding name in which
//     the output XML stream would be, but must be aware that if
//     characters, unrepresentable in the encoding specified, appearing
//     in markups, may force the serializer to terminate serialization
//     prematurely, and thus no complete serialization would be done.
//
// Application shall query the serializer first, before set any
//           feature/mode(true, false), or be ready to catch exception if this
//           feature/mode is not supported by the serializer.
//
// Application needs to clean up the filter, error handler and
//     format target objects created for the serialization.
//
//   Limitations:
//      1. The encoding="xxx" clause in the XML header should reflect
//          the system local code page, but does not.
//      2. Cases where the XML data contains characters that can not
//          be represented in the system local code page are not handled.
//
// ---------------------------------------------------------------------------

#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>
#include <xercesc/dom/DOMWriter.hpp>

#include <xercesc/framework/StdOutFormatTarget.hpp>
#include <xercesc/framework/LocalFileFormatTarget.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/util/XMLUni.hpp>

#include "DOMTreeErrorReporter.hpp"
#include "DOMPrintFilter.hpp"
#include "DOMPrintErrorHandler.hpp"
#include <xercesc/util/OutOfMemoryException.hpp>

#include <string.h>
#include <stdlib.h>

// ---------------------------------------------------------------------------
// Local data
//
// gXmlFile
//      The path to the file to parser. Set via command line.
//
// gDoNamespaces
//      Indicates whether namespace processing should be done.
//
// gDoSchema
//      Indicates whether schema processing should be done.
//
// gSchemaFullChecking
//      Indicates whether full schema constraint checking should be done.
//
// gDoCreate
//      Indicates whether entity reference nodes needs to be created or not
//      Defaults to false
//
// gOutputEncoding
//      The encoding we are to output in. If not set on the command line,
//      then it is defaults to the encoding of the input XML file.
//
// gSplitCdataSections
//      Indicates whether split-cdata-sections is to be enabled or not.
//
// gDiscardDefaultContent
//      Indicates whether default content is discarded or not.
//
// gUseFilter
//      Indicates if user wants to plug in the DOMPrintFilter.
//
// gValScheme
//      Indicates what validation scheme to use. It defaults to 'auto', but
//      can be set via the -v= command.
//
// ---------------------------------------------------------------------------
static char*                    gXmlFile               = 0;
static bool                     gDoNamespaces          = false;
static bool                     gDoSchema              = false;
static bool                     gSchemaFullChecking    = false;
static bool                     gDoCreate              = false;

static char* goutputfile = 0;
// options for DOMWriter's features
static XMLCh* gOutputEncoding = 0;

static bool                     gSplitCdataSections    = true;
static bool                     gDiscardDefaultContent = true;
static bool                     gUseFilter             = false;
static bool                     gFormatPrettyPrint     = false;
static bool                     gWriteBOM              = false;

static XercesDOMParser::ValSchemes gValScheme = XercesDOMParser::Val_Auto;

// Prototypes for internally used functions
void usage();

// ---------------------------------------------------------------------------
//
// Usage()
//
// ---------------------------------------------------------------------------
void usage()
{
    XERCES_STD_QUALIFIER cout << "/nUsage:/n"
            "    DOMPrint [options] <XML file>/n/n"
            "This program invokes the DOM parser, and builds the DOM tree./n"
            "It then asks the DOMWriter to serialize the DOM tree./n"
            "Options:/n"
            "    -e          create entity reference nodes. Default is no expansion./n"
            "    -v=xxx      Validation scheme [always | never | auto*]./n"
            "    -n          Enable namespace processing. Default is off./n"
            "    -s          Enable schema processing. Default is off./n"
            "    -f          Enable full schema constraint checking. Defaults is off./n"
            "    -wenc=XXX   Use a particular encoding for output. Default is/n"
            "                the same encoding as the input XML file. UTF-8 if/n"
            "                input XML file has not XML declaration./n"
            "    -wfile=xxx Write to a file instead of stdout./n"
            "    -wscs=xxx   Enable/Disable split-cdata-sections.      Default on/n"
            "    -wddc=xxx   Enable/Disable discard-default-content.   Default on/n"
            "    -wflt=xxx   Enable/Disable filtering.                 Default off/n"
            "    -wfpp=xxx   Enable/Disable format-pretty-print.       Default off/n"
            "    -wbom=xxx   Enable/Disable write Byte-Order-Mark      Default off/n"
            "    -?          Show this help./n/n"
            " * = Default if not provided explicitly./n/n"
            "The parser has intrinsic support for the following encodings:/n"
            "    UTF-8, USASCII, ISO8859-1, UTF-16[BL]E, UCS-4[BL]E,/n"
            "    WINDOWS-1252, IBM1140, IBM037, IBM1047./n"
          << XERCES_STD_QUALIFIER endl;
}

// ---------------------------------------------------------------------------
//
// main
//
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
int retval = 0;

    // Initialize the XML4C2 system
    try
    {
        XMLPlatformUtils::Initialize();
    }

    catch(const XMLException &toCatch)
    {
        XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization./n"
             << " Exception message:"
             << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
        return 1;
    }

    // Check command line and extract arguments.
    if (argC < 2)
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 1;
    }

    // See if non validating dom parser configuration is requested.
    int parmInd;
    for (parmInd = 1; parmInd < argC; parmInd++)
    {
        // Break out on first parm not starting with a dash
        if (argV[parmInd][0] != '-')
            break;

        // Watch for special case help request
        if (!strcmp(argV[parmInd], "-?"))
        {
            usage();
            XMLPlatformUtils::Terminate();
            return 2;
        }
         else if (!strncmp(argV[parmInd], "-v=", 3)
              || !strncmp(argV[parmInd], "-V=", 3))
        {
            const char* const parm = &argV[parmInd][3];

            if (!strcmp(parm, "never"))
                gValScheme = XercesDOMParser::Val_Never;
            else if (!strcmp(parm, "auto"))
                gValScheme = XercesDOMParser::Val_Auto;
            else if (!strcmp(parm, "always"))
                gValScheme = XercesDOMParser::Val_Always;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else if (!strcmp(argV[parmInd], "-n")
              || !strcmp(argV[parmInd], "-N"))
        {
            gDoNamespaces = true;
        }
         else if (!strcmp(argV[parmInd], "-s")
              || !strcmp(argV[parmInd], "-S"))
        {
            gDoSchema = true;
        }
         else if (!strcmp(argV[parmInd], "-f")
              || !strcmp(argV[parmInd], "-F"))
        {
            gSchemaFullChecking = true;
        }
         else if (!strcmp(argV[parmInd], "-e")
              || !strcmp(argV[parmInd], "-E"))
        {
            gDoCreate = true;
        }
         else if (!strncmp(argV[parmInd], "-wenc=", 6))
        {
             // Get out the encoding name
             gOutputEncoding = XMLString::transcode( &(argV[parmInd][6]) );
        }
         else if (!strncmp(argV[parmInd], "-wfile=", 7))
        {
             goutputfile = &(argV[parmInd][7]);
        }
         else if (!strncmp(argV[parmInd], "-wddc=", 6))
        {
            const char* const parm = &argV[parmInd][6];

            if (!strcmp(parm, "on"))
    gDiscardDefaultContent = true;
            else if (!strcmp(parm, "off"))
    gDiscardDefaultContent = false;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -wddc= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }

        }
         else if (!strncmp(argV[parmInd], "-wscs=", 6))
        {
            const char* const parm = &argV[parmInd][6];

            if (!strcmp(parm, "on"))
    gSplitCdataSections = true;
   else if (!strcmp(parm, "off"))
    gSplitCdataSections = false;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -wscs= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else if (!strncmp(argV[parmInd], "-wflt=", 6))
        {
            const char* const parm = &argV[parmInd][6];

            if (!strcmp(parm, "on"))
    gUseFilter = true;
   else if (!strcmp(parm, "off"))
    gUseFilter = false;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -wflt= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else if (!strncmp(argV[parmInd], "-wfpp=", 6))
        {
            const char* const parm = &argV[parmInd][6];

            if (!strcmp(parm, "on"))
    gFormatPrettyPrint = true;
   else if (!strcmp(parm, "off"))
    gFormatPrettyPrint = false;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -wfpp= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else if (!strncmp(argV[parmInd], "-wbom=", 6))
        {
            const char* const parm = &argV[parmInd][6];

            if (!strcmp(parm, "on"))
                gWriteBOM = true;
            else if (!strcmp(parm, "off"))
                gWriteBOM = false;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -wbom= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else
        {
            XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[parmInd]
                 << "', ignoring it./n" << XERCES_STD_QUALIFIER endl;
        }
    }

    //
    // And now we have to have only one parameter left and it must be
    // the file name.
    //
    if (parmInd + 1 != argC)
    {
        usage();
        XMLPlatformUtils::Terminate();
        return 1;
    }
    gXmlFile = argV[parmInd];

    //
    // Create our parser, then attach an error handler to the parser.
    // The parser will call back to methods of the ErrorHandler if it
    // discovers errors during the course of parsing the XML document.
    //
    XercesDOMParser *parser = new XercesDOMParser;
    parser->setValidationScheme(gValScheme);
    parser->setDoNamespaces(gDoNamespaces);
    parser->setDoSchema(gDoSchema);
    parser->setValidationSchemaFullChecking(gSchemaFullChecking);
    parser->setCreateEntityReferenceNodes(gDoCreate);

DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter();
parser->setErrorHandler(errReporter);

    //
    // Parse the XML file, catching any XML exceptions that might propogate
    // out of it.
    //
    bool errorsOccured = false;
    try
    {
        parser->parse(gXmlFile);
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorsOccured = true;
    }
    catch (const XMLException& e)
    {
        XERCES_STD_QUALIFIER cerr << "An error occurred during parsing/n   Message: "
             << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
        errorsOccured = true;
    }

    catch (const DOMException& e)
    {
        const unsigned int maxChars = 2047;
        XMLCh errText[maxChars + 1];

XERCES_STD_QUALIFIER cerr << "/nDOM Error during parsing: '" << gXmlFile << "'/n"
<< "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;

if (DOMImplementation::loadDOMExceptionMsg(e.code, errText, maxChars))
XERCES_STD_QUALIFIER cerr << "Message is: " << StrX(errText) << XERCES_STD_QUALIFIER endl;

errorsOccured = true;
}

    catch (...)
    {
        XERCES_STD_QUALIFIER cerr << "An error occurred during parsing/n " << XERCES_STD_QUALIFIER endl;
        errorsOccured = true;
    }

    // If the parse was successful, output the document data from the DOM tree
    if (!errorsOccured && !errReporter->getSawErrors())
    {
        DOMPrintFilter   *myFilter = 0;

        try
        {
            // get a serializer, an instance of DOMWriter
            XMLCh tempStr[100];
            XMLString::transcode("LS", tempStr, 99);
            DOMImplementation *impl          = DOMImplementationRegistry::getDOMImplementation(tempStr);
            DOMWriter         *theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter();

// set user specified output encoding
theSerializer->setEncoding(gOutputEncoding);

            // plug in user's own filter
            if (gUseFilter)
            {
                // even we say to show attribute, but the DOMWriter
                // will not show attribute nodes to the filter as
                // the specs explicitly says that DOMWriter shall
                // NOT show attributes to DOMWriterFilter.
                //
                // so DOMNodeFilter::SHOW_ATTRIBUTE has no effect.
                // same DOMNodeFilter::SHOW_DOCUMENT_TYPE, no effect.
                //
                myFilter = new DOMPrintFilter(DOMNodeFilter::SHOW_ELEMENT   |
                                              DOMNodeFilter::SHOW_ATTRIBUTE |
                                              DOMNodeFilter::SHOW_DOCUMENT_TYPE);
                theSerializer->setFilter(myFilter);
            }

            // plug in user's own error handler
            DOMErrorHandler *myErrorHandler = new DOMPrintErrorHandler();
            theSerializer->setErrorHandler(myErrorHandler);

            // set feature if the serializer supports the feature/mode
            if (theSerializer->canSetFeature(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections))
                theSerializer->setFeature(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections);

if (theSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent))
theSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent);

if (theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint))
theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint);

if (theSerializer->canSetFeature(XMLUni::fgDOMWRTBOM, gWriteBOM))
theSerializer->setFeature(XMLUni::fgDOMWRTBOM, gWriteBOM);

            //
            // Plug in a format target to receive the resultant
            // XML stream from the serializer.
            //
            // StdOutFormatTarget prints the resultant XML stream
            // to stdout once it receives any thing from the serializer.
            //
            XMLFormatTarget *myFormTarget;
            if (goutputfile)
                myFormTarget = new LocalFileFormatTarget(goutputfile);
            else
                myFormTarget = new StdOutFormatTarget();

// get the DOM representation
DOMNode *doc = parser->getDocument();

            //
            // do the serialization through DOMWriter::writeNode();
            //
            theSerializer->writeNode(myFormTarget, *doc);

delete theSerializer;

            //
            // Filter, formatTarget and error handler
            // are NOT owned by the serializer.
            //
            delete myFormTarget;
            delete myErrorHandler;

if (gUseFilter)
delete myFilter;

        }
        catch (const OutOfMemoryException&)
        {
            XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
            retval = 5;
        }
        catch (XMLException& e)
        {
            XERCES_STD_QUALIFIER cerr << "An error occurred during creation of output transcoder. Msg is:"
                << XERCES_STD_QUALIFIER endl
                << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
            retval = 4;
        }

    }
    else
        retval = 4;

    //
    // Clean up the error handler. The parser does not adopt handlers
    // since they could be many objects or one object installed for multiple
    // handlers.
    //
    delete errReporter;

    //
    // Delete the parser itself. Must be done prior to calling Terminate, below.
    //
    delete parser;

// And call the termination method
XMLPlatformUtils::Terminate();

XMLString::release(&gOutputEncoding);

return retval;
}

//DOMPrintErrorHandler.hpp

/*
* $Id: DOMPrintErrorHandler.hpp 568078 2007-08-21 11:43:25Z amassari $
* $Log$
* Revision 1.3 2004/09/08 13:55:31 peiyongz
* Apache License Version 2.0
*
* Revision 1.2 2002/11/05 21:46:19 tng
* Explicit code using namespace in application.
*
* Revision 1.1 2002/05/29 21:19:50 peiyongz
* DOM3 DOMWriter/DOMWriterFilter
*
*
*/

#ifndef DOM_PRINT_ERROR_HANDLER_HPP
#define DOM_PRINT_ERROR_HANDLER_HPP

#include <xercesc/dom/DOMErrorHandler.hpp>

XERCES_CPP_NAMESPACE_USE

class DOMPrintErrorHandler : public DOMErrorHandler
{
public:

DOMPrintErrorHandler(){};
~DOMPrintErrorHandler(){};

    /** @name The error handler interface */
    bool handleError(const DOMError& domError);
    void resetErrors(){};

private :
    /* Unimplemented constructors and operators */
    DOMPrintErrorHandler(const DOMErrorHandler&);
    void operator=(const DOMErrorHandler&);

};

#endif

//DOMPrintErrorHandler.cpp

/*
* $Id: DOMPrintErrorHandler.cpp 568078 2007-08-21 11:43:25Z amassari $
* $Log$
* Revision 1.7 2004/09/08 13:55:31 peiyongz
* Apache License Version 2.0
*
* Revision 1.6 2003/05/30 09:36:35 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.5 2003/02/05 18:53:22 tng
* [Bug 11915] Utility for freeing memory.
*
* Revision 1.4 2002/12/10 15:36:36 tng
* DOMPrint minor update: print error message to XERCES_STD_QUALIFIER cerr.
*
* Revision 1.3 2002/06/13 14:55:01 peiyongz
* Fix to UNIX compilation failure
*
* Revision 1.2 2002/06/11 19:46:28 peiyongz
* Display error message received from the serializer.
*
* Revision 1.1 2002/05/29 21:19:50 peiyongz
* DOM3 DOMWriter/DOMWriterFilter
*
*
*/

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

#include "DOMPrintErrorHandler.hpp"

bool DOMPrintErrorHandler::handleError(const DOMError &domError)
{
    // Display whatever error message passed from the serializer
    if (domError.getSeverity() == DOMError::DOM_SEVERITY_WARNING)
        XERCES_STD_QUALIFIER cerr << "/nWarning Message: ";
    else if (domError.getSeverity() == DOMError::DOM_SEVERITY_ERROR)
        XERCES_STD_QUALIFIER cerr << "/nError Message: ";
    else
        XERCES_STD_QUALIFIER cerr << "/nFatal Message: ";

    char *msg = XMLString::transcode(domError.getMessage());
    XERCES_STD_QUALIFIER cerr<< msg <<XERCES_STD_QUALIFIER endl;
    XMLString::release(&msg);

// Instructs the serializer to continue serialization if possible.
return true;
}

//DOMPrintFilter.hpp

/*
* $Id: DOMPrintFilter.hpp 568078 2007-08-21 11:43:25Z amassari $
* $Log$
* Revision 1.5 2004/09/08 13:55:31 peiyongz
* Apache License Version 2.0
*
* Revision 1.4 2002/11/05 21:46:19 tng
* Explicit code using namespace in application.
*
* Revision 1.3 2002/06/04 14:22:51 peiyongz
* Implement setter/getter from DOMWriterFilter
*
* Revision 1.2 2002/06/03 22:40:07 peiyongz
* *** empty log message ***
*
* Revision 1.1 2002/05/29 13:33:32 peiyongz
* DOM3 Save Interface: DOMWriter/DOMWriterFilter
*
*/

//
// DOMPrintFilter.hpp: a sample implementation of DOMWriterFilter.
//
//

#ifndef DOMPrintFilter_HEADER_GUARD_
#define DOMPrintFilter_HEADER_GUARD_

#include <xercesc/dom/DOMWriterFilter.hpp>

XERCES_CPP_NAMESPACE_USE

class DOMPrintFilter : public DOMWriterFilter {
public:

/** @name Constructors */
DOMPrintFilter(unsigned long whatToShow = DOMNodeFilter::SHOW_ALL);
//@{

/** @name Destructors */
~DOMPrintFilter(){};
//@{

/** @ interface from DOMWriterFilter */
virtual short acceptNode(const DOMNode*) const;
//@{

virtual unsigned long getWhatToShow() const {return fWhatToShow;};

virtual void setWhatToShow(unsigned long toShow) {fWhatToShow = toShow;};

private:
// unimplemented copy ctor and assignement operator
DOMPrintFilter(const DOMPrintFilter&);
DOMPrintFilter & operator = (const DOMPrintFilter&);

unsigned long fWhatToShow;

};

#endif

//DOMPrintFilter.cpp

/*
* $Id: DOMPrintFilter.cpp 568078 2007-08-21 11:43:25Z amassari $
* $Log$
* Revision 1.4 2004/09/08 13:55:31 peiyongz
* Apache License Version 2.0
*
* Revision 1.3 2002/06/04 14:22:51 peiyongz
* Implement setter/getter from DOMWriterFilter
*
* Revision 1.2 2002/06/03 22:40:07 peiyongz
* *** empty log message ***
*
* Revision 1.1 2002/05/29 13:33:32 peiyongz
* DOM3 Save Interface: DOMWriter/DOMWriterFilter
*
*/

#include "DOMPrintFilter.hpp"
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLString.hpp>

static const XMLCh element_person[]=
{
chLatin_p, chLatin_e, chLatin_r, chLatin_s, chLatin_o, chLatin_n, chNull
};

static const XMLCh element_link[]=
{
chLatin_l, chLatin_i, chLatin_n, chLatin_k, chNull
};

DOMPrintFilter::DOMPrintFilter(unsigned long whatToShow)
:fWhatToShow(whatToShow)
{}

short DOMPrintFilter::acceptNode(const DOMNode* node) const
{
//
// The DOMWriter shall call getWhatToShow() before calling
// acceptNode(), to show nodes which are supposed to be
// shown to this filter.
//
// REVISIT: In case the DOMWriter does not follow the protocol,
//          Shall the filter honour, or NOT, what it claimes
//         (when it is constructed/setWhatToShow())
//          it is interested in ?
//
// The DOMLS specs does not specify that acceptNode() shall do
// this way, or not, so it is up the implementation,
// to skip the code below for the sake of performance ...
//
if ((getWhatToShow() & (1 << (node->getNodeType() - 1))) == 0)
  return DOMNodeFilter::FILTER_ACCEPT;

switch (node->getNodeType())
{
case DOMNode::ELEMENT_NODE:
  {
   // for element whose name is "person", skip it
   if (XMLString::compareString(node->getNodeName(), element_person)==0)
    return DOMNodeFilter::FILTER_SKIP;
   // for element whose name is "line", reject it
   if (XMLString::compareString(node->getNodeName(), element_link)==0)
    return DOMNodeFilter::FILTER_REJECT;
   // for rest, accept it
   return DOMNodeFilter::FILTER_ACCEPT;

   break;
  }
case DOMNode::COMMENT_NODE:
  {
   // the WhatToShow will make this no effect
   return DOMNodeFilter::FILTER_REJECT;
   break;
  }
case DOMNode::TEXT_NODE:
  {
   // the WhatToShow will make this no effect
   return DOMNodeFilter::FILTER_REJECT;
   break;
  }
case DOMNode::DOCUMENT_TYPE_NODE:
  {
   // even we say we are going to process document type,
   // we are not able be to see this node since
   // DOMWriterImpl (a XercesC's default implementation
   // of DOMWriter) will not pass DocumentType node to
   // this filter.
   //
   return DOMNodeFilter::FILTER_REJECT; // no effect
   break;
  }
case DOMNode::DOCUMENT_NODE:
  {
   // same as DOCUMENT_NODE
   return DOMNodeFilter::FILTER_REJECT; // no effect
   break;
  }
default :
  {
   return DOMNodeFilter::FILTER_ACCEPT;
   break;
  }
}

return DOMNodeFilter::FILTER_ACCEPT;
}

//DOMTreeErrorReporter.hpp

/*
* $Id: DOMTreeErrorReporter.hpp 568078 2007-08-21 11:43:25Z amassari $
*/

#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/sax/ErrorHandler.hpp>
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif

XERCES_CPP_NAMESPACE_USE

class DOMTreeErrorReporter : public ErrorHandler
{
public:
    // -----------------------------------------------------------------------
    // Constructors and Destructor
    // -----------------------------------------------------------------------
    DOMTreeErrorReporter() :
       fSawErrors(false)
    {
    }

    ~DOMTreeErrorReporter()
    {
    }

    // -----------------------------------------------------------------------
    // Implementation of the error handler interface
    // -----------------------------------------------------------------------
    void warning(const SAXParseException& toCatch);
    void error(const SAXParseException& toCatch);
    void fatalError(const SAXParseException& toCatch);
    void resetErrors();

    // -----------------------------------------------------------------------
    // Getter methods
    // -----------------------------------------------------------------------
    bool getSawErrors() const;

    // -----------------------------------------------------------------------
    // Private data members
    //
    // fSawErrors
    //      This is set if we get any errors, and is queryable via a getter
    //      method. Its used by the main code to suppress output if there are
    //      errors.
    // -----------------------------------------------------------------------
    bool    fSawErrors;
};

inline bool DOMTreeErrorReporter::getSawErrors() const
{
return fSawErrors;
}

// ---------------------------------------------------------------------------
// This is a simple class that lets us do easy (though not terribly efficient)
// trancoding of XMLCh data to local code page for display.
// ---------------------------------------------------------------------------
class StrX
{
public :
    // -----------------------------------------------------------------------
    // Constructors and Destructor
    // -----------------------------------------------------------------------
    StrX(const XMLCh* const toTranscode)
    {
        // Call the private transcoding method
        fLocalForm = XMLString::transcode(toTranscode);
    }

    ~StrX()
    {
        XMLString::release(&fLocalForm);
    }

private :
    // -----------------------------------------------------------------------
    // Private data members
    //
    // fLocalForm
    //      This is the local code page form of the string.
    // -----------------------------------------------------------------------
    char*   fLocalForm;
};

inline XERCES_STD_QUALIFIER ostream& operator<<(XERCES_STD_QUALIFIER ostream& target, const StrX& toDump)
{
target << toDump.localForm();
return target;
}

//DOMTreeErrorReporter.cpp

/*
* $Id: DOMTreeErrorReporter.cpp 568078 2007-08-21 11:43:25Z amassari $
*/

// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/sax/SAXParseException.hpp>
#include "DOMTreeErrorReporter.hpp"
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif
#include <stdlib.h>
#include <string.h>

void DOMTreeErrorReporter::warning(const SAXParseException&)
{
    //
    // Ignore all warnings.
    //
}

void DOMTreeErrorReporter::error(const SAXParseException& toCatch)
{
    fSawErrors = true;
    XERCES_STD_QUALIFIER cerr << "Error at file /"" << StrX(toCatch.getSystemId())
   << "/", line " << toCatch.getLineNumber()
   << ", column " << toCatch.getColumnNumber()
         << "/n   Message: " << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void DOMTreeErrorReporter::fatalError(const SAXParseException& toCatch)
{
    fSawErrors = true;
    XERCES_STD_QUALIFIER cerr << "Fatal Error at file /"" << StrX(toCatch.getSystemId())
   << "/", line " << toCatch.getLineNumber()
   << ", column " << toCatch.getColumnNumber()
         << "/n   Message: " << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void DOMTreeErrorReporter::resetErrors()
{
fSawErrors = false;
}