|| || || || || || || ||

---

Sax2Reader.h

Go to the documentation of this file.

#ifndef Impala_Application_SDash_Sax2Reader_h
#define Impala_Application_SDash_Sax2Reader_h

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
#if defined(XERCES_NEW_IOSTREAMS)
#include <fstream>
#else
#include <fstream.h>
#endif
#include <xercesc/util/OutOfMemoryException.hpp>

#include "Application/sdash/StrX.h"
#include "Application/sdash/Sax2Handler.h"

namespace Impala {
namespace Application {
namespace SDash {


class Sax2Reader {

public:

    // SK: I kept the parameters from the main() of a SAX2 sample:

    //    "Usage:"
    //        "    [options] <XML file | List file>"
    //        "This program invokes the SAX2XMLReader, and then prints the"
    //        "number of elements, attributes, spaces and characters found"
    //        "in each XML file, using SAX2 API."
    //        "Options:"
    //        "    -l          Indicate the input file is a List File that has a list of xml files."
    //        "                Default to off (Input file is an XML file)."
    //        "    -v=xxx      Validation scheme [always | never | auto*]."
    //        "    -f          Enable full schema constraint checking processing. Defaults to off."
    //        "    -p          Enable namespace-prefixes feature. Defaults to off."
    //        "    -n          Disable namespace processing. Defaults to on."
    //        "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES."
    //        "    -s          Disable schema processing. Defaults to on."
    //        "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES."
    //        "    -i          Disable identity constraint checking. Defaults to on."
    //        "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES."
    //        "    -locale=ll_CC specify the locale, default: en_US."
    //        "  * = Default if not provided explicitly."

    Sax2Reader(int argC, const char* argV[], Sax2Handler* handler) : mParser(0)
    {
        mProperlyConstructed = true;

        mValScheme = SAX2XMLReader::Val_Auto;
        mDoNamespaces = true;
        mDoSchema = true;
        mSchemaFullChecking = false;
        mIdentityConstraintChecking = true;
        mDoList = false;
        mNamespacePrefixes = false;
        mRecognizeNEL = false;

        memset(mLocaleStr, 0, sizeof mLocaleStr);

        // check the flags
        int argInd;
        for (argInd = 0; argInd < argC; argInd++)
        {
            // Break out on first parm not starting with a dash
            if (argV[argInd][0] != '-')
                break;

            if (!strncmp(argV[argInd], "-v=", 3)
                  ||  !strncmp(argV[argInd], "-V=", 3))
            {
                const char* const parm = &argV[argInd][3];

                if (!strcmp(parm, "never"))
                    mValScheme = SAX2XMLReader::Val_Never;
                else if (!strcmp(parm, "auto"))
                    mValScheme = SAX2XMLReader::Val_Auto;
                else if (!strcmp(parm, "always"))
                    mValScheme = SAX2XMLReader::Val_Always;
                else
                {
                    XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
                    mProperlyConstructed = false;
                    return;
                }
            }
             else if (!strcmp(argV[argInd], "-n")
                  ||  !strcmp(argV[argInd], "-N"))
            {
                mDoNamespaces = false;
            }
             else if (!strcmp(argV[argInd], "-s")
                  ||  !strcmp(argV[argInd], "-S"))
            {
                mDoSchema = false;
            }
             else if (!strcmp(argV[argInd], "-f")
                  ||  !strcmp(argV[argInd], "-F"))
            {
                mSchemaFullChecking = true;
            }
             else if (!strcmp(argV[argInd], "-i")
                  ||  !strcmp(argV[argInd], "-I"))
            {
                mIdentityConstraintChecking = false;
            }
             else if (!strcmp(argV[argInd], "-l")
                  ||  !strcmp(argV[argInd], "-L"))
            {
                mDoList = true;
            }
             else if (!strcmp(argV[argInd], "-p")
                  ||  !strcmp(argV[argInd], "-P"))
            {
                mNamespacePrefixes = true;
            }
             else if (!strcmp(argV[argInd], "-special:nel"))
            {
                // turning this on will lead to non-standard compliance behaviour
                // it will recognize the unicode character 0x85 as new line character
                // instead of regular character as specified in XML 1.0
                // do not turn this on unless really necessary
                 mRecognizeNEL = true;
            }
             else if (!strncmp(argV[argInd], "-locale=", 8))
            {
                 // Get out the end of line
                 strncpy(mLocaleStr, &(argV[argInd][8]), sizeof mLocaleStr);
            }                   
            else
            {
                XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
                    << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
            }
        }

        //
        //  There should be one and only one parameter left, and that
        //  should be the file name.
        //
        if (argInd != argC - 1)
        {
            XERCES_STD_QUALIFIER cerr << "Invalid parameter count to Sax2Reader::Sax2Reader(..)"
                << XERCES_STD_QUALIFIER endl;
            mProperlyConstructed = false;
            return;
        }
        mFileToRead = std::string(argV[argInd]);

        // Initialize the XML4C2 system
        try
        {
            if (strlen(mLocaleStr))
            {
                XMLPlatformUtils::Initialize(mLocaleStr);
            }
            else
            {
                XMLPlatformUtils::Initialize();
            }

            if (mRecognizeNEL)
            {
                XMLPlatformUtils::recognizeNEL(mRecognizeNEL);
            }
        }

        catch (const XMLException& toCatch)
        {
            XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
                << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
            mProperlyConstructed = false;
            return;
        }

        //
        //  According to what we were told on
        //  the command line, set the parser to validate or not.
        //
        mParser = XMLReaderFactory::createXMLReader();
        mParser->setFeature(XMLUni::fgSAX2CoreNameSpaces, mDoNamespaces);
        mParser->setFeature(XMLUni::fgXercesSchema, mDoSchema);
        mParser->setFeature(XMLUni::fgXercesSchemaFullChecking, mSchemaFullChecking);
        mParser->setFeature(XMLUni::fgXercesIdentityConstraintChecking, mIdentityConstraintChecking);
        mParser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, mNamespacePrefixes);

        if (mValScheme == SAX2XMLReader::Val_Auto)
        {
            mParser->setFeature(XMLUni::fgSAX2CoreValidation, true);
            mParser->setFeature(XMLUni::fgXercesDynamic, true);
        }
        if (mValScheme == SAX2XMLReader::Val_Never)
        {
            mParser->setFeature(XMLUni::fgSAX2CoreValidation, false);
        }
        if (mValScheme == SAX2XMLReader::Val_Always)
        {
            mParser->setFeature(XMLUni::fgSAX2CoreValidation, true);
            mParser->setFeature(XMLUni::fgXercesDynamic, false);
        }

        mParser->setContentHandler(handler);
        mParser->setErrorHandler(handler);
        mHandler = handler;

    } //ctor

    virtual ~Sax2Reader()
    {
        if (mHandler != 0)
            delete mHandler;

        //  Deleting the parser must be done prior to calling Terminate, below.
        if (mParser != 0)
            delete mParser;

        XMLPlatformUtils::Terminate();
    }

    virtual bool ProperlyConstructed()
    {
        return mProperlyConstructed;
    }

    Sax2Handler* GetHandler() const
    {
        return mHandler;
    }

    // uses the file name passed into the ctor 
    int Read()
    {
        if (mFileToRead.empty())
            return 1;

        const char* fileToParse = 0;
        unsigned long duration;
        bool errorOccurred = false;

        bool more = true;
        XERCES_STD_QUALIFIER ifstream fin;

        // the input is a list file
        if (mDoList)
            fin.open(mFileToRead.c_str());

        if (fin.fail()) {
            XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << mFileToRead << XERCES_STD_QUALIFIER endl;
            return 2;
        }

        while (more)
        {
            char fURI[1000];
            //initialize the array to zeros
            memset(fURI,0,sizeof(fURI));

            if (mDoList) {
                if (! fin.eof() ) {
                    fin.getline (fURI, sizeof(fURI));
                    if (!*fURI)
                        continue;
                    else {
                        fileToParse = fURI;
                        XERCES_STD_QUALIFIER cerr << "==Parsing== " << fileToParse << XERCES_STD_QUALIFIER endl;
                    }
                }
                else
                    break;
            }
            else {
                fileToParse = mFileToRead.c_str();
                more = false; // not a list, parse just one file
            }

            mHandler->resetErrors();

            try
            {
                const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
                mParser->parse(fileToParse);
                const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
                duration = endMillis - startMillis;
            }
            catch (const OutOfMemoryException&)
            {
                XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
                errorOccurred = true;
                continue;
            }
            catch (const XMLException& e)
            {
                XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << fileToParse << "'\n"
                    << "Exception message is:  \n"
                    << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
                errorOccurred = true;
                continue;
            }

            catch (...)
            {
                XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << fileToParse << "'\n";
                errorOccurred = true;
                continue;
            }

            if (!mHandler->getSawErrors())
            {
                //XERCES_STD_QUALIFIER cout << fileToParse << ": " << duration << " ms" << XERCES_STD_QUALIFIER endl;
            }
            else
                errorOccurred = true;

        } // while (more)

        if (mDoList)
            fin.close();

        if (errorOccurred)
            return 3; // if failed on at least one xml file to be parsed 
        else
            return 0;

    } // Read()


protected:

    std::string mFileToRead;


private:

    SAX2XMLReader* mParser;
    Sax2Handler* mHandler;

    SAX2XMLReader::ValSchemes    mValScheme;
    bool                         mDoNamespaces;
    bool                         mDoSchema;
    bool                         mSchemaFullChecking;
    bool                         mIdentityConstraintChecking;
    bool                         mDoList;
    bool                         mNamespacePrefixes;
    bool                         mRecognizeNEL;
    char                         mLocaleStr[64];

    bool mProperlyConstructed;

}; //class

}
}
}

#endif

---