Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

XalanFileUtility.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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.
 */
#if !defined(XALAN_FILEUTILITY_HEADER_GUARD_1357924680)
#define XALAN_FILEUTILITY_HEADER_GUARD_1357924680



#include "xalanc/Harness/XalanHarnessDefinitions.hpp"


#include "xalanc/Include/XalanVector.hpp"


#if defined(XALAN_CLASSIC_IOSTREAMS)
#include <strstream.h>
#else
#include <strstream>
#endif



#include "xalanc/XalanDOM/XalanDOMString.hpp"



XALAN_CPP_NAMESPACE_BEGIN



class FormatterListener;
class PrintWriter;
class StylesheetRoot;
class XalanCompiledStylesheet;
class XalanDocument;
class XalanNode;
class XalanSourceTreeDocument;
class XalanTransformer;
class XalanXMLFileReporter;
class XSLTInputSource;


XALAN_USING_XERCES(MemoryManager)



// This class is exported from the Harness.dll
class XALAN_HARNESS_EXPORT XalanFileUtility 
{
public:

// A vector to hold directory names and file names.

    typedef XalanVector<XalanDOMString>     FileNameVectorType;


    struct XALAN_HARNESS_EXPORT reportStruct
    {
        XalanDOMString  theDrive;
        XalanDOMString  testOrFile;
        XalanDOMString  xmlFileURL;
        XalanDOMString  xslFileURL;
        XalanDOMString  xmlFormat;
        const char*     msg;
        XalanDOMString  currentNode;
        XalanDOMString  actual;
        XalanDOMString  expected;
        int             pass;
        int             fail;
        int             nogold;

        reportStruct(MemoryManager& theManager);

        void
        reset();
    private:
        //Not implemented
        reportStruct();
        reportStruct(const reportStruct&);

    } data;

    struct XALAN_HARNESS_EXPORT cmdParams
    {
    private:

#if defined(XALAN_NO_STD_NAMESPACE)
        typedef ostrstream          StreamType;
#else
        typedef std::ostrstream     StreamType;
#endif

        StreamType  help;

    public:

        XalanDOMString  base;
        XalanDOMString  output;
        XalanDOMString  gold;
        XalanDOMString  sub;
        int             source;
        bool            skip;
        long            iters;


        cmdParams(MemoryManager& theManager);

        ~cmdParams()
        {
        }

        const char*
        getHelpMessage();

        StreamType&
        getHelpStream()
        {
            return help;
        }
    private:
        //Not implemented
        cmdParams();
        cmdParams(const cmdParams&);

    } args;

    XalanFileUtility(MemoryManager& theManager);

    ~XalanFileUtility();


    XalanDOMString&
    getDrive(XalanDOMString& theResult);

    bool
    getParams(
            int             argc,
            char*           argv[],
            const char*     outDir,
            bool            fsetGold = true);


    FileNameVectorType&
    getTestFileNames(
            const XalanDOMString&   baseDir,
            const XalanDOMString&   relDir,
            bool                    useDirPrefix,
            FileNameVectorType&     theFiles);
  
    FileNameVectorType&
    getDirectoryNames(const XalanDOMString&     rootDirectory,
                      FileNameVectorType&       theFiles);

    void
    checkAndCreateDir(const XalanDOMString&     directory);

    bool
    checkDir(const XalanDOMString&  directory);

    XalanDOMString&
    getXSLFileName(const XalanDOMString&    theXMLFileName,
                    XalanDOMString&         theResult);

    XalanDOMString&
    generateFileName(
            const XalanDOMString&  theXMLFileName,
            const char*             suffix,
            XalanDOMString&         theResult,
            bool*                   status = 0);

    XalanDOMString&
    generateUniqRunid(XalanDOMString& theResult);

    XalanDOMString&
    getXercesVersion(XalanDOMString& theResult);


    void
    checkResults(
            const XalanDOMString&   outputFile, 
            const XalanDOMString&   goldFile, 
            XalanXMLFileReporter&   logfile);

    void
    checkAPIResults(
            const XalanDOMString&   actual, 
            const XalanDOMString&   expected,
            const char*             msg,
            XalanXMLFileReporter&   logfile,
            const XalanDOMString&   outputFile,
            const XalanDOMString&   goldFile,
            bool                    containsOnly = false);

    // This API is deprecated.  Please use the following
    // one.
    void
    checkAPIResults(
            const char*             actual,
            const char*             expected,
            const char*             msg,
            XalanXMLFileReporter&        logfile,
            const XalanDOMString&   outputFile,
            const XalanDOMString&   goldFile,
            MemoryManager&          /* theManager */,
            bool                    containsOnly = false)
    {
        checkAPIResults(
            actual,
            expected,
            msg,
            logfile,
            outputFile,
            goldFile,
            containsOnly);
    }

    void
    checkAPIResults(
            const char*             actual,
            const char*             expected,
            const char*             msg,
            XalanXMLFileReporter&   logfile,
            const XalanDOMString&   outputFile,
            const XalanDOMString&   goldFile,
            bool                    containsOnly = false)
    {
        checkAPIResults(
            XalanDOMString(actual, m_memoryManager), 
            XalanDOMString(expected, m_memoryManager),
            msg,
            logfile,
            outputFile,
            goldFile,
            containsOnly);
    }

    void
    checkDOMResults(
            const XalanDOMString&           theOutputFile, 
            const XalanCompiledStylesheet*  compiledSS,
            const XalanSourceTreeDocument*  dom,
            const XSLTInputSource&          goldInputSource,
            XalanXMLFileReporter&                logfile);

    bool
    compareSerializedResults(
            const XalanDOMString&   transformResult,
            const XalanDOMString&   goldInputSource);
    FormatterListener* 
    getXMLFormatter(
            PrintWriter&            resultWriter,
            int                     indentAmount,
            const XalanDOMString&   mimeEncoding,
            const StylesheetRoot*   stylesheet);


    bool
    fileCompare(
            const char*     goldFile,
            const char*     outputFile);

    bool 
    domCompare(const XalanNode& gold, const XalanNode& doc);

    bool 
    domCompare(
            const XalanDocument&    gold,
            const XalanDocument&    doc);

    bool 
    diffElement(const XalanNode& gold, const XalanNode& doc);

    bool
    diffNode(
            const XalanNode&    gold,
            const XalanNode&    doc);

    bool
    diffNode(
            const XalanNode*    gold,
            const XalanNode*    doc);

    bool 
    diffElement2(
            const XalanNode&    gold,
            const XalanNode&    doc);

    bool 
    diffAttr(const XalanNode* gAttr, const XalanNode* dAttr);

    void
    reportPassFail(XalanXMLFileReporter& logfile);

    void
    reportPassFail(XalanXMLFileReporter& logfile, const XalanDOMString& runid);

    void
    analyzeResults(XalanTransformer& xalan, const XalanDOMString& resultsFile);

    static const XalanDOMChar   s_xmlSuffix[];

    static const XalanDOMChar   s_pathSep[];

    const MemoryManager&
    getMemoryManager() const
    {
        return m_memoryManager;
    }

    MemoryManager&
    getMemoryManager()
    {
        return m_memoryManager;
    }

private:

    static const XalanDOMString     s_emptyString;

    XalanDOMString&
    getProgramName(const char* fullName, XalanDOMString& theBuffer);

    void 
    collectData(
            const char*             errmsg,
            const XalanDOMString&   currentnode,
            const XalanDOMString&   actdata,
            const XalanDOMString&   expdata);

    void
    reportError();

#if defined(NDEBUG)
    void
    debugNodeData(const XalanDOMString&     /* value */) const
    {
    }

    void
    debugNodeData(
            const XalanDOMString&   /* node */,
            const XalanDOMString&   /* value */) const
    {
    }

    void
    debugAttributeData(const XalanDOMString&    /* value */) const
    {
    }

#else

    void
    debugNodeData(const XalanDOMString&     value) const;

    void
    debugNodeData(
            const XalanDOMString&   node,
            const XalanDOMString&   value) const;

    void
    debugAttributeData(const XalanDOMString&    value) const;

#endif
private:

    MemoryManager&  m_memoryManager;

    //Not implemented
    XalanFileUtility();
    XalanFileUtility(const XalanFileUtility&);
};



XALAN_CPP_NAMESPACE_END



#endif  // XALAN_FILEUTILITY_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.