SAX2Print

最新推荐文章于 2024-09-23 17:41:18 发布

zhujun012

最新推荐文章于 2024-09-23 17:41:18 发布

阅读量448

点赞数

文章标签： permissions apache file equals express output

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

版权

//SAX2Print.hpp

/*
* 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.
*/

/*
* $Log$
* Revision 1.4 2004/09/08 13:55:33 peiyongz
* Apache License Version 2.0
*
* Revision 1.3 2003/05/30 09:36:36 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.2 2003/02/05 18:53:23 tng
* [Bug 11915] Utility for freeing memory.
*
* Revision 1.1 2000/08/02 19:16:14 jpolast
* initial checkin of SAX2Print
*
*
*/

// ---------------------------------------------------------------------------
// Includes for all the program files to see
// ---------------------------------------------------------------------------
#include <string.h>
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif
#include <stdlib.h>
#include "SAX2PrintHandlers.hpp"

// ---------------------------------------------------------------------------
// 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);
    }

    // -----------------------------------------------------------------------
    // Getter methods
    // -----------------------------------------------------------------------
    const char* localForm() const
    {
        return 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;
}

//SAX2Print.cpp

/*
* $Log$
* Revision 1.18 2004/12/24 19:21:46 amassari
* Add support for SAX2 filters (jira# 1133)
*
* Revision 1.17 2004/09/08 13:55:33 peiyongz
* Apache License Version 2.0
*
* Revision 1.16 2004/09/02 14:59:29 cargilld
* Add OutOfMemoryException block to samples.
*
* Revision 1.15 2004/02/06 15:04:16 cargilld
* Misc 390 changes.
*
* Revision 1.14 2003/08/07 21:21:38 neilg
* fix segmentation faults that may arise when the parser throws exceptions during document parsing. In general, XMLPlatformUtils::Terminate() should not be called from within a catch statement.
*
* Revision 1.13 2003/05/30 09:36:36 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.12 2002/06/17 15:33:00 tng
* Name Xerces features as XMLUni::fgXercesXXXX instead of XMLUni::fgSAX2XercesXXXX so that they can be shared with DOM parser.
*
* Revision 1.11 2002/05/28 20:20:26 tng
* Add option '-n' to SAX2Print.
*
* Revision 1.10 2002/04/17 20:18:08 tng
* [Bug 7493] The word "occured" is misspelled and it is a global error.
*
* Revision 1.9 2002/02/13 16:11:06 knoaman
* Update samples to use SAX2 features/properties constants from XMLUni.
*
* Revision 1.8 2002/02/06 16:36:51 knoaman
* Added a new flag '-p' to SAX2 samples to set the 'namespace-prefixes' feature.
*
* Revision 1.7 2002/02/01 22:40:44 peiyongz
* sane_include
*
* Revision 1.6 2001/10/25 15:18:33 tng
* delete the parser before XMLPlatformUtils::Terminate.
*
* Revision 1.5 2001/10/19 19:02:43 tng
* [Bug 3909] return non-zero an exit code when error was encounted.
* And other modification for consistent help display and return code across samples.
*
* Revision 1.4 2001/08/02 17:10:29 tng
* Allow DOMCount/SAXCount/IDOMCount/SAX2Count to take a file that has a list of xml file as input.
*
* Revision 1.3 2001/08/01 19:11:01 tng
* Add full schema constraint checking flag to the samples and the parser.
*
* Revision 1.2 2000/08/09 22:20:38 jpolast
* updates for changes to sax2 core functionality.
*
* Revision 1.1 2000/08/02 19:16:14 jpolast
* initial checkin of SAX2Print
*
*
*/

// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
#include "SAX2Print.hpp"
#include <xercesc/util/OutOfMemoryException.hpp>
#include "SAX2FilterHandlers.hpp"

// ---------------------------------------------------------------------------
// Local data
//
// encodingName
//      The encoding we are to output in. If not set on the command line,
//      then it is defaulted to LATIN1.
//
// xmlFile
//      The path to the file to parser. Set via command line.
//
// valScheme
//      Indicates what validation scheme to use. It defaults to 'auto', but
//      can be set via the -v= command.
//
// expandNamespaces
//  Indicates if the output should expand the namespaces Alias with
//  their URI's, defaults to false, can be set via the command line -e
// ---------------------------------------------------------------------------
static const char*              encodingName    = "LATIN1";
static XMLFormatter::UnRepFlags unRepFlags      = XMLFormatter::UnRep_CharRef;
static char*                    xmlFile         = 0;
static SAX2XMLReader::ValSchemes valScheme      = SAX2XMLReader::Val_Auto;
static bool             expandNamespaces= false ;
static bool                     doNamespaces    = true;
static bool                     doSchema        = true;
static bool                     schemaFullChecking = false;
static bool                     namespacePrefixes = false;
static bool                     sortAttributes = false;

// ---------------------------------------------------------------------------
// Local helper methods
// ---------------------------------------------------------------------------
static void usage()
{
    XERCES_STD_QUALIFIER cout << "/nUsage:/n"
            "    SAX2Print [options] <XML file>/n/n"
            "This program invokes the SAX2XMLReader, and then prints the/n"
            "data returned by the various SAX2 handlers for the specified/n"
            "XML file./n/n"
            "Options:/n"
             "    -u=xxx      Handle unrepresentable chars [fail | rep | ref*]./n"
             "    -v=xxx      Validation scheme [always | never | auto*]./n"
             "    -e          Expand Namespace Alias with URI's. Defaults to off./n"
             "    -x=XXX      Use a particular encoding for output (LATIN1*)./n"
             "    -f          Enable full schema constraint checking processing. Defaults to off./n"
             "    -p          Enable namespace-prefixes feature. Defaults to off./n"
             "    -n          Disable namespace processing. Defaults to on./n"
             "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES./n"
             "    -s          Disable schema processing. Defaults to on./n"
             "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES./n"
             "    -sa         Print the attributes in alfabetic order. Defaults to 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;
}

// ---------------------------------------------------------------------------
// Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
    // Initialize the XML4C2 system
    try
    {
         XMLPlatformUtils::Initialize();
    }

    catch (const XMLException& toCatch)
    {
         XERCES_STD_QUALIFIER cerr << "Error during initialization! :/n"
              << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
         return 1;
    }

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

    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"))
                valScheme = SAX2XMLReader::Val_Never;
            else if (!strcmp(parm, "auto"))
                valScheme = SAX2XMLReader::Val_Auto;
            else if (!strcmp(parm, "always"))
                valScheme = SAX2XMLReader::Val_Always;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else if (!strcmp(argV[parmInd], "-e")
              || !strcmp(argV[parmInd], "-E"))
        {
            expandNamespaces = true;
        }
         else if (!strncmp(argV[parmInd], "-x=", 3)
              || !strncmp(argV[parmInd], "-X=", 3))
        {
            // Get out the encoding name
            encodingName = &argV[parmInd][3];
        }
         else if (!strncmp(argV[parmInd], "-u=", 3)
              || !strncmp(argV[parmInd], "-U=", 3))
        {
            const char* const parm = &argV[parmInd][3];

            if (!strcmp(parm, "fail"))
                unRepFlags = XMLFormatter::UnRep_Fail;
            else if (!strcmp(parm, "rep"))
                unRepFlags = XMLFormatter::UnRep_Replace;
            else if (!strcmp(parm, "ref"))
                unRepFlags = XMLFormatter::UnRep_CharRef;
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown -u= value: " << parm << XERCES_STD_QUALIFIER endl;
                XMLPlatformUtils::Terminate();
                return 2;
            }
        }
         else if (!strcmp(argV[parmInd], "-n")
              || !strcmp(argV[parmInd], "-N"))
        {
            doNamespaces = false;
        }
         else if (!strcmp(argV[parmInd], "-s")
              || !strcmp(argV[parmInd], "-S"))
        {
            doSchema = false;
        }
         else if (!strcmp(argV[parmInd], "-f")
              || !strcmp(argV[parmInd], "-F"))
        {
            schemaFullChecking = true;
        }
         else if (!strcmp(argV[parmInd], "-p")
              || !strcmp(argV[parmInd], "-P"))
        {
            namespacePrefixes = true;
        }
         else if (!strcmp(argV[parmInd], "-sa"))
        {
            sortAttributes = true;
        }
         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;
    }
    xmlFile = argV[parmInd];

    //
    // Create a SAX parser object. Then, according to what we were told on
    // the command line, set it to validate or not.
    //
    SAX2XMLReader* parser;
    SAX2XMLReader* reader = XMLReaderFactory::createXMLReader();
    SAX2XMLReader* filter = NULL;
    if(sortAttributes)
    {
        filter=new SAX2SortAttributesFilter(reader);
        parser=filter;
    }
    else
        parser=reader;

    //
    // Then, according to what we were told on
    // the command line, set it to validate or not.
    //
    if (valScheme == SAX2XMLReader::Val_Auto)
    {
        parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
        parser->setFeature(XMLUni::fgXercesDynamic, true);
    }

    if (valScheme == SAX2XMLReader::Val_Never)
    {
        parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
    }

    if (valScheme == SAX2XMLReader::Val_Always)
    {
        parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
        parser->setFeature(XMLUni::fgXercesDynamic, false);
    }

    parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, doNamespaces);
    parser->setFeature(XMLUni::fgXercesSchema, doSchema);
    parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
    parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, namespacePrefixes);

    //
    // Create the handler object and install it as the document and error
    // handler for the parser. Then parse the file and catch any exceptions
    // that propogate out
    //

    int errorCount = 0;
    int errorCode = 0;
    try
    {
        SAX2PrintHandlers handler(encodingName, unRepFlags, expandNamespaces);
        parser->setContentHandler(&handler);
        parser->setErrorHandler(&handler);
        parser->parse(xmlFile);
        errorCount = parser->getErrorCount();
    }
    catch (const OutOfMemoryException&)
    {
        XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
        errorCode = 5;
    }
    catch (const XMLException& toCatch)
    {
        XERCES_STD_QUALIFIER cerr << "/nAn error occurred/n Error: "
             << StrX(toCatch.getMessage())
             << "/n" << XERCES_STD_QUALIFIER endl;
        errorCode = 4;
    }

    if(errorCode) {
        XMLPlatformUtils::Terminate();
        return errorCode;
    }

    //
    // Delete the parser itself. Must be done prior to calling Terminate, below.
    //
    delete reader;
    if(filter)
        delete filter;

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

    if (errorCount > 0)
        return 4;
    else
        return 0;
}

//SAX2PrintHandlers.hpp

/*
* $Log$
* Revision 1.7 2004/09/08 13:55:33 peiyongz
* Apache License Version 2.0
*
* Revision 1.6 2004/02/15 19:43:15 amassari
* Removed cause for warnings in VC 7.1
*
* Revision 1.5 2002/11/05 21:46:20 tng
* Explicit code using namespace in application.
*
* Revision 1.4 2002/02/01 22:40:44 peiyongz
* sane_include
*
* Revision 1.3 2000/10/10 23:55:55 andyh
* XMLFormatter patch, contributed by Bill Schindler. Fix problems with
* output to multi-byte encodings.
*
* Revision 1.2 2000/08/09 22:20:39 jpolast
* updates for changes to sax2 core functionality.
*
* Revision 1.1 2000/08/02 19:16:14 jpolast
* initial checkin of SAX2Print
*
*
*/

#include <xercesc/sax2/DefaultHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>

XERCES_CPP_NAMESPACE_USE

class SAX2PrintHandlers : public DefaultHandler, private XMLFormatTarget
{
public:
    // -----------------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------------
    SAX2PrintHandlers
    (
        const   char* const                 encodingName
        , const XMLFormatter::UnRepFlags    unRepFlags
  , const bool      expandNamespaces
    );
    ~SAX2PrintHandlers();

    // -----------------------------------------------------------------------
    // Implementations of the format target interface
    // -----------------------------------------------------------------------
    void writeChars
    (
        const   XMLByte* const toWrite
    );

    void writeChars
    (
        const   XMLByte* const toWrite
        , const unsigned int    count
        , XMLFormatter* const   formatter
    );

    // -----------------------------------------------------------------------
    // Implementations of the SAX DocumentHandler interface
    // -----------------------------------------------------------------------
    void endDocument();

    void endElement( const XMLCh* const uri,
      const XMLCh* const localname,
      const XMLCh* const qname);

void characters(const XMLCh* const chars, const unsigned int length);

    void ignorableWhitespace
    (
        const   XMLCh* const    chars
        , const unsigned int    length
    );

    void processingInstruction
    (
        const   XMLCh* const    target
        , const XMLCh* const    data
    );

void startDocument();

    void startElement( const   XMLCh* const    uri,
      const   XMLCh* const    localname,
      const   XMLCh* const    qname,
         const   Attributes&  attributes);

    // -----------------------------------------------------------------------
    // Implementations of the SAX ErrorHandler interface
    // -----------------------------------------------------------------------
    void warning(const SAXParseException& exc);
    void error(const SAXParseException& exc);
    void fatalError(const SAXParseException& exc);

    // -----------------------------------------------------------------------
    // Implementation of the SAX DTDHandler interface
    // -----------------------------------------------------------------------
    void notationDecl
    (
        const   XMLCh* const    name
        , const XMLCh* const    publicId
        , const XMLCh* const    systemId
    );

    void unparsedEntityDecl
    (
        const   XMLCh* const    name
        , const XMLCh* const    publicId
        , const XMLCh* const    systemId
        , const XMLCh* const    notationName
    );

private :
    // -----------------------------------------------------------------------
    // Private data members
    //
    // fFormatter
    //      This is the formatter object that is used to output the data
    //      to the target. It is set up to format to the standard output
    //      stream.
    // -----------------------------------------------------------------------
    XMLFormatter    fFormatter;
bool   fExpandNS ;
};

//SAX2PrintHandlers.cpp

/*
* $Log$
* Revision 1.11 2005/01/12 20:43:21 cargilld
* Remove warning messages.
*
* Revision 1.10 2004/09/08 13:55:33 peiyongz
* Apache License Version 2.0
*
* Revision 1.9 2003/05/30 09:36:36 gareth
* Use new macros for iostream.h and std:: issues.
*
* Revision 1.8 2003/03/17 21:03:52 peiyongz
* Bug#17983
*
* Revision 1.7 2002/05/28 20:24:15 tng
* XMLUni::fgEmptyString which is defined as "EMPTY" is incorrectly used as an empty string, should use XMLUni::fgZeroLenString instead
*
* Revision 1.6 2002/02/01 22:40:44 peiyongz
* sane_include
*
* Revision 1.5 2001/05/11 13:24:57 tng
* Copyright update.
*
* Revision 1.4 2001/05/03 16:00:03 tng
* Schema: samples update with schema
*
* Revision 1.3 2000/10/10 23:55:53 andyh
* XMLFormatter patch, contributed by Bill Schindler. Fix problems with
* output to multi-byte encodings.
*
* Revision 1.2 2000/08/09 22:20:38 jpolast
* updates for changes to sax2 core functionality.
*
* Revision 1.1 2000/08/02 19:16:14 jpolast
* initial checkin of SAX2Print
*
*
*/

// ---------------------------------------------------------------------------
// Local const data
//
// Note: This is the 'safe' way to do these strings. If you compiler supports
//        L"" style strings, and portability is not a concern, you can use
//        those types constants directly.
// ---------------------------------------------------------------------------
static const XMLCh gEndElement[] = { chOpenAngle, chForwardSlash, chNull };
static const XMLCh gEndPI[] = { chQuestion, chCloseAngle, chNull };
static const XMLCh gStartPI[] = { chOpenAngle, chQuestion, chNull };
static const XMLCh gXMLDecl1[] =
{
        chOpenAngle, chQuestion, chLatin_x, chLatin_m, chLatin_l
    ,   chSpace, chLatin_v, chLatin_e, chLatin_r, chLatin_s, chLatin_i
    ,   chLatin_o, chLatin_n, chEqual, chDoubleQuote, chDigit_1, chPeriod
    ,   chDigit_0, chDoubleQuote, chSpace, chLatin_e, chLatin_n, chLatin_c
    ,   chLatin_o, chLatin_d, chLatin_i, chLatin_n, chLatin_g, chEqual
    ,   chDoubleQuote, chNull
};

static const XMLCh gXMLDecl2[] =
{
chDoubleQuote, chQuestion, chCloseAngle
, chLF, chNull
};

// ---------------------------------------------------------------------------
// SAX2PrintHandlers: Constructors and Destructor
// ---------------------------------------------------------------------------
SAX2PrintHandlers::SAX2PrintHandlers( const   char* const              encodingName
                                    , const XMLFormatter::UnRepFlags unRepFlags
         , const bool      expandNamespaces) :

    fFormatter
    (
        encodingName
        , 0
        , this
        , XMLFormatter::NoEscapes
        , unRepFlags
    ),
fExpandNS ( expandNamespaces )
{
    //
    // Go ahead and output an XML Decl with our known encoding. This
    // is not the best answer, but its the best we can do until we
    // have SAX2 support.
    //
    fFormatter << gXMLDecl1 << fFormatter.getEncodingName() << gXMLDecl2;
}

SAX2PrintHandlers::~SAX2PrintHandlers()
{
}

// ---------------------------------------------------------------------------
// SAX2PrintHandlers: Overrides of the output formatter target interface
// ---------------------------------------------------------------------------
void SAX2PrintHandlers::writeChars(const XMLByte* const /* toWrite */)
{
}

void SAX2PrintHandlers::writeChars(const XMLByte* const toWrite,
                                   const unsigned int count,
                                   XMLFormatter* const /* formatter */)
{
    // For this one, just dump them to the standard output
    // Surprisingly, Solaris was the only platform on which
    // required the char* cast to print out the string correctly.
    // Without the cast, it was printing the pointer value in hex.
    // Quite annoying, considering every other platform printed
    // the string with the explicit cast to char* below.
    XERCES_STD_QUALIFIER cout.write((char *) toWrite, (int) count);
XERCES_STD_QUALIFIER cout.flush();
}

// ---------------------------------------------------------------------------
// SAX2PrintHandlers: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void SAX2PrintHandlers::error(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "/nError at file " << StrX(e.getSystemId())
   << ", line " << e.getLineNumber()
   << ", char " << e.getColumnNumber()
         << "/n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void SAX2PrintHandlers::fatalError(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "/nFatal Error at file " << StrX(e.getSystemId())
   << ", line " << e.getLineNumber()
   << ", char " << e.getColumnNumber()
         << "/n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

void SAX2PrintHandlers::warning(const SAXParseException& e)
{
    XERCES_STD_QUALIFIER cerr << "/nWarning at file " << StrX(e.getSystemId())
   << ", line " << e.getLineNumber()
   << ", char " << e.getColumnNumber()
         << "/n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
}

// ---------------------------------------------------------------------------
// SAX2PrintHandlers: Overrides of the SAX DTDHandler interface
// ---------------------------------------------------------------------------
void SAX2PrintHandlers::unparsedEntityDecl(const    XMLCh* const /* name */
                                          , const   XMLCh* const /* publicId */
                                          , const   XMLCh* const /* systemId */
                                          , const   XMLCh* const /* notationName */)
{
    // Not used at this time
}

void SAX2PrintHandlers::notationDecl(const XMLCh* const /* name */
                                    , const XMLCh* const /* publicId */
                                    , const XMLCh* const /* systemId */)
{
    // Not used at this time
}

// ---------------------------------------------------------------------------
// SAX2PrintHandlers: Overrides of the SAX DocumentHandler interface
// ---------------------------------------------------------------------------
void SAX2PrintHandlers::characters(const     XMLCh* const    chars
                                  , const   unsigned int    length)
{
    fFormatter.formatBuf(chars, length, XMLFormatter::CharEscapes);
}

void SAX2PrintHandlers::endDocument()
{
}

void SAX2PrintHandlers::endElement(const XMLCh* const uri,
         const XMLCh* const localname,
         const XMLCh* const qname)
{
    // No escapes are legal here
    fFormatter << XMLFormatter::NoEscapes << gEndElement ;
if ( fExpandNS )
{
  if (XMLString::compareIString(uri,XMLUni::fgZeroLenString) != 0)
    fFormatter << uri << chColon;
  fFormatter << localname << chCloseAngle;
}
else
  fFormatter << qname << chCloseAngle;
}

void SAX2PrintHandlers::ignorableWhitespace( const   XMLCh* const chars
                                            ,const unsigned int length)
{
    fFormatter.formatBuf(chars, length, XMLFormatter::NoEscapes);
}

void SAX2PrintHandlers::processingInstruction(const XMLCh* const target
                                            , const XMLCh* const data)
{
    fFormatter << XMLFormatter::NoEscapes << gStartPI << target;
    if (data)
        fFormatter << chSpace << data;
    fFormatter << XMLFormatter::NoEscapes << gEndPI;
}

void SAX2PrintHandlers::startDocument()
{
}

void SAX2PrintHandlers::startElement(const   XMLCh* const    uri,
         const   XMLCh* const    localname,
         const   XMLCh* const    qname,
                                    const   Attributes&  attributes)
{
    // The name has to be representable without any escapes
    fFormatter << XMLFormatter::NoEscapes << chOpenAngle ;
if ( fExpandNS )
{
  if (XMLString::compareIString(uri,XMLUni::fgZeroLenString) != 0)
    fFormatter << uri << chColon;
  fFormatter << localname ;
}
else
  fFormatter << qname ;

    unsigned int len = attributes.getLength();
    for (unsigned int index = 0; index < len; index++)
    {
        //
        // Again the name has to be completely representable. But the
        // attribute can have refs and requires the attribute style
        // escaping.
        //
        fFormatter << XMLFormatter::NoEscapes << chSpace ;
  if ( fExpandNS )
  {
   if (XMLString::compareIString(attributes.getURI(index),XMLUni::fgZeroLenString) != 0)
    fFormatter << attributes.getURI(index) << chColon;
   fFormatter << attributes.getLocalName(index) ;
  }
  else
   fFormatter << attributes.getQName(index) ;

  fFormatter << chEqual << chDoubleQuote
                    << XMLFormatter::AttrEscapes
              << attributes.getValue(index)
                    << XMLFormatter::NoEscapes
                    << chDoubleQuote;
    }
    fFormatter << chCloseAngle;
}

//SAX2FilterHandlers.hpp

/*
* $Log$
* Revision 1.1 2004/12/24 19:44:21 amassari
* Add support for SAX2 filters (jira# 1133)
*
*
*/

#include <xercesc/parsers/SAX2XMLFilterImpl.hpp>

XERCES_CPP_NAMESPACE_USE

class SAX2SortAttributesFilter : public SAX2XMLFilterImpl
{
public:
    // -----------------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------------
    SAX2SortAttributesFilter(SAX2XMLReader* parent);
    ~SAX2SortAttributesFilter();

    // -----------------------------------------------------------------------
    // Implementations of the SAX2XMLFilter interface
    // -----------------------------------------------------------------------
    void startElement( const   XMLCh* const    uri,
      const   XMLCh* const    localname,
      const   XMLCh* const    qname,
         const   Attributes&  attributes);
};

//SAX2FilterHandlers.cpp

/*
* $Log$
* Revision 1.2 2005/02/07 13:20:40 amassari
* Removed warnings
*
* Revision 1.1 2004/12/24 19:44:21 amassari
* Add support for SAX2 filters (jira# 1133)
*
*
*/

struct Attr
{
    const XMLCh* qName;
    const XMLCh* uri;
    const XMLCh* localPart;
    const XMLCh* value;
    const XMLCh* attrType;
};

class AttrList : public Attributes, public RefVectorOf<Attr>
{
public:
AttrList(unsigned count) : RefVectorOf<Attr>(count) {}

    virtual unsigned int getLength() const
    {
        return size();
    }

virtual const XMLCh* getURI(const unsigned int index) const
    {
        return elementAt(index)->uri;
    }
    virtual const XMLCh* getLocalName(const unsigned int index) const
    {
        return elementAt(index)->localPart;
    }
    virtual const XMLCh* getQName(const unsigned int index) const
    {
        return elementAt(index)->qName;
    }
    virtual const XMLCh* getType(const unsigned int index) const
    {
        return elementAt(index)->attrType;
    }
    virtual const XMLCh* getValue(const unsigned int index) const
    {
        return elementAt(index)->value;
    }

virtual int getIndex(const XMLCh* const uri, const XMLCh* const localPart ) const
    {
        for(unsigned int i=0;i<size();i++)
            if(XMLString::equals(elementAt(i)->uri,uri) && XMLString::equals(elementAt(i)->localPart,localPart))
                return i;
        return -1;
    }
virtual int getIndex(const XMLCh* const qName ) const
    {
        for(unsigned int i=0;i<size();i++)
            if(XMLString::equals(elementAt(i)->qName,qName))
                return i;
        return -1;
    }

virtual const XMLCh* getType(const XMLCh* const uri, const XMLCh* const localPart ) const
    {
        for(unsigned int i=0;i<size();i++)
            if(XMLString::equals(elementAt(i)->uri,uri) && XMLString::equals(elementAt(i)->localPart,localPart))
                return elementAt(i)->attrType;
        return NULL;
    }
    virtual const XMLCh* getType(const XMLCh* const qName) const
    {
        for(unsigned int i=0;i<size();i++)
            if(XMLString::equals(elementAt(i)->qName,qName))
                return elementAt(i)->attrType;
        return NULL;
    }

virtual const XMLCh* getValue(const XMLCh* const uri, const XMLCh* const localPart ) const
    {
        for(unsigned int i=0;i<size();i++)
            if(XMLString::equals(elementAt(i)->uri,uri) && XMLString::equals(elementAt(i)->localPart,localPart))
                return elementAt(i)->value;
        return NULL;
    }
    virtual const XMLCh* getValue(const XMLCh* const qName) const
    {
        for(unsigned int i=0;i<size();i++)
            if(XMLString::equals(elementAt(i)->qName,qName))
                return elementAt(i)->value;
        return NULL;
    }

};

// ---------------------------------------------------------------------------
// SAX2SortAttributesFilter: Constructors and Destructor
// ---------------------------------------------------------------------------
SAX2SortAttributesFilter::SAX2SortAttributesFilter(SAX2XMLReader* parent) : SAX2XMLFilterImpl(parent)
{
}

SAX2SortAttributesFilter::~SAX2SortAttributesFilter()
{
}

// ---------------------------------------------------------------------------
// SAX2SortAttributesFilter: Overrides of the SAX2XMLFilter interface
// ---------------------------------------------------------------------------
void SAX2SortAttributesFilter::startElement(const   XMLCh* const    uri,
         const   XMLCh* const    localname,
         const   XMLCh* const    qname,
                                    const   Attributes&  attributes)
{
    AttrList sortedList(attributes.getLength());
    for(unsigned int i=0;i<attributes.getLength();i++)
    {
        unsigned int j;
        for(j=0;j<sortedList.getLength();j++)
        {
            if(XMLString::compareString(sortedList.elementAt(j)->qName,attributes.getQName(i))>=0)
                break;
        }
        Attr* pClone=new Attr;
        pClone->qName       = attributes.getQName(i);
        pClone->uri         = attributes.getURI(i);
        pClone->localPart   = attributes.getLocalName(i);
        pClone->value       = attributes.getValue(i);
        pClone->attrType    = attributes.getType(i);
        sortedList.insertElementAt(pClone, j);
    }
    SAX2XMLFilterImpl::startElement(uri, localname, qname, sortedList);
}