Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.9

FormatterToXML.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(FORMATTERTOXML_HEADER_GUARD_1357924680)
#define FORMATTERTOXML_HEADER_GUARD_1357924680




// Base include file.  Must be first.
#include <xalanc/XMLSupport/XMLSupportDefinitions.hpp>



#include <xalanc/Include/XalanVector.hpp>



#include <xalanc/XalanDOM/XalanDOMString.hpp>



#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/XalanUnicode.hpp>



// Base class header file.
#include <xalanc/PlatformSupport/FormatterListener.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class Writer;
class XalanOutputStream;



class XALAN_XMLSUPPORT_EXPORT FormatterToXML : public FormatterListener 
{
public:

    enum eDummy
    {
        eDefaultIndentAmount = 0
    };

    FormatterToXML(
            Writer&                 writer,
            const XalanDOMString&   version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    doIndent = false,
            int                     indent = eDefaultIndentAmount,
            const XalanDOMString&   encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    xmlDecl = true,
            const XalanDOMString&   standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            eFormat                 format = OUTPUT_METHOD_XML,
            bool                    fBufferData = true,
            MemoryManagerType&      theManager XALAN_DEFAULT_MEMMGR);
    
    static FormatterToXML*
    create(
            MemoryManagerType&      theManager,
            Writer&                 writer,
            const XalanDOMString&   version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    doIndent = false,
            int                     indent = eDefaultIndentAmount,
            const XalanDOMString&   encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    xmlDecl = true,
            const XalanDOMString&   standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            eFormat                 format = OUTPUT_METHOD_XML,
            bool                    fBufferData = true);

    virtual
    ~FormatterToXML();

    MemoryManagerType&
    getMemoryManager()
    {
        return m_stringBuffer.getMemoryManager();
    }

    // These methods are inherited from FormatterListener ...

    virtual void
    setDocumentLocator(const LocatorType* const     locator);

    virtual void
    startDocument();

    virtual void
    endDocument();

    virtual void
    startElement(
            const XMLCh* const  name,
            AttributeListType&  attrs);

    virtual void
    endElement(const XMLCh* const   name);

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

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

    virtual void
    entityReference(const XMLCh* const  name);

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

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


    virtual void
    resetDocument();

    virtual void
    comment(const XMLCh* const  data);

    virtual void
    cdata(
            const XMLCh* const  ch,
            const unsigned int  length);

    virtual Writer*
    getWriter() const;

    virtual const XalanDOMString&
    getDoctypeSystem() const;

    virtual const XalanDOMString&
    getDoctypePublic() const;

    virtual const XalanDOMString&
    getEncoding() const;

    virtual const XalanDOMString&
    getMediaType() const;

    virtual int
    getIndent() const;

    const XalanDOMString&
    getVersion() const
    {
        return m_version;
    }

    const XalanDOMString&
    getStandalone() const
    {
        return m_standalone;
    }

    bool
    getShouldWriteXMLHeader() const
    {
        return m_shouldWriteXMLHeader;
    }

    void
    setShouldWriteXMLHeader(bool    b)
    {
        m_shouldWriteXMLHeader = b;
    }

    bool
    getStripCData() const
    {
        return m_stripCData;
    }

    void
    setStripCData(bool  b)
    {
        m_stripCData = b;
    }

    bool
    getEscapeCData() const
    {
        return m_escapeCData;
    }

    void
    setEscapeCData(bool b)
    {
        m_escapeCData = b;
    }

    bool
    getDoIndent() const
    {
        return m_doIndent;
    }

    void
    setDoIndent(bool    value)
    {
        m_doIndent = value;
    }

    void
    setIndent(int   value)
    {
        m_indent = value;
    }


    typedef XalanVector<bool>           BoolStackType;
    typedef XalanVector<XalanDOMChar>   DOMCharBufferType;
    typedef XalanVector<char>           ByteBufferType;


protected:

    Writer* const               m_writer;

    XalanOutputStream* const    m_stream;

    void
    outputLineSep();

    typedef void (FormatterToXML::*AccumCharFunctionType)(XalanDOMChar);

    typedef void (FormatterToXML::*AccumStringFunctionType)(const XalanDOMChar*);

    typedef void (FormatterToXML::*AccumDOMStringFunctionType)(const XalanDOMString&);

    typedef void (FormatterToXML::*AccumArrayFunctionType)(
                        const XalanDOMChar[],
                        XalanDOMString::size_type,
                        XalanDOMString::size_type);

    typedef void (FormatterToXML::*FlushFunctionType)();

    void
    accumName(XalanDOMChar  ch)
    {
        assert(m_accumNameCharFunction != 0);

        (this->*m_accumNameCharFunction)(ch);
    }

    void
    accumContent(XalanDOMChar   ch)
    {
        assert(m_accumContentCharFunction != 0);

        (this->*m_accumContentCharFunction)(ch);
    }

    void
    accumName(const XalanDOMChar*   chars)
    {
        assert(m_accumNameStringFunction != 0);

        (this->*m_accumNameStringFunction)(chars);
    }

    void
    accumContent(const XalanDOMChar*    chars)
    {
        assert(m_accumContentStringFunction != 0);

        (this->*m_accumContentStringFunction)(chars);
    }

    void
    accumName(
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length)
    {
        assert(m_accumNameArrayFunction != 0);

        (this->*m_accumNameArrayFunction)(chars, start, length);
    }

    void
    accumContent(
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length)
    {
        assert(m_accumContentArrayFunction != 0);

        (this->*m_accumContentArrayFunction)(chars, start, length);
    }

    void
    accumName(const XalanDOMString&     str)
    {
        assert(m_accumNameDOMStringFunction != 0);

        (this->*m_accumNameDOMStringFunction)(str);
    }

    void
    accumContent(const XalanDOMString&  str)
    {
        assert(m_accumContentDOMStringFunction != 0);

        (this->*m_accumContentDOMStringFunction)(str);
    }

    XalanDOMString::size_type
    accumDefaultEscape(
            XalanDOMChar                ch,
            XalanDOMString::size_type   i,
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   len,
            bool                        escLF);

    virtual bool
    accumDefaultEntity(
            XalanDOMChar    ch,
            bool            escLF);

    void
    initAttrCharsMap();

    void
    initCharsMap();

    void
    flushChars();

    void
    flushBytes();

    void
    flushWriter();

    void
    openElementForChildren();

    bool
    childNodesWereAdded();

    bool
    shouldIndent() const
    {
        return m_doIndent && (!m_ispreserve && !m_isprevtext);
    }

    void
    writeParentTagEnd();

    void
    indent(int  n);

    virtual void
    writeNormalizedChars(
            const XalanDOMChar          ch[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length,
            bool                        isCData);

    void
    writeNumberedEntityReference(unsigned long  theNumber);

    virtual void
    writeAttrString(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theStringLength);

    virtual void
    accumCommentData(const XalanDOMChar*    data);

    static void
    throwInvalidUTF16SurrogateException(XalanDOMChar    ch,
                                        MemoryManagerType& theManager);

    static void
    throwInvalidUTF16SurrogateException(
            XalanDOMChar    ch,
            XalanDOMChar    next,
            MemoryManagerType& theManager);

    static bool
    isUTF16Surrogate(XalanDOMChar   ch)
    {
        return (ch & 0xFC00) == 0xD800 ? true : false;
    }

    enum eDummyTwo { SPECIALSSIZE = 256};

    XalanDOMChar            m_maxCharacter;

    XalanDOMChar            m_attrCharsMap[SPECIALSSIZE];

    XalanDOMChar            m_charsMap[SPECIALSSIZE];

    bool        m_shouldWriteXMLHeader;

    bool        m_ispreserve;

    bool        m_doIndent;

    bool        m_startNewLine;
  
    bool        m_needToOutputDocTypeDecl;
  
    bool        m_isprevtext;

    bool        m_stripCData;

    bool        m_nextIsRaw;

    bool        m_inCData;

    bool        m_encodingIsUTF;

    const XalanDOMString    m_doctypeSystem;

    const XalanDOMString    m_doctypePublic;

    XalanDOMString  m_encoding;

    int     m_currentIndent;
  
    int     m_indent;

    BoolStackType   m_preserves;

    // A text buffer.  We use it mostly for converting
    // to string values.  See uses of UnsignedLongToString()
    // and UnsignedLongToHexString().
    XalanDOMString  m_stringBuffer;

private:

    // These are not implemented.
    FormatterToXML(const FormatterToXML&);

    FormatterToXML&
    operator=(const FormatterToXML&);

    bool
    operator==(const FormatterToXML&) const;

    void
    accumNameAsByte(XalanDOMChar    ch);

    void
    accumNameAsByteDirect(XalanDOMChar  ch);

    void
    accumContentAsByte(XalanDOMChar     ch);

    void
    accumContentAsByteDirect(XalanDOMChar   ch);

    void
    accumNameAsChar(XalanDOMChar    ch);

    void
    accumNameAsCharDirect(XalanDOMChar  ch);

    void
    accumContentAsChar(XalanDOMChar     ch);

    void
    accumContentAsCharDirect(XalanDOMChar   ch);

    void
    accumCharUTF(XalanDOMChar   ch);

    void
    accumCharUTFDirect(XalanDOMChar ch);

    void
    accumNameString(const XalanDOMChar* chars);

    void
    accumStringUTF(const XalanDOMChar*  chars);

    void
    accumStringUTFDirect(const XalanDOMChar*    chars);

    void
    accumContentString(const XalanDOMChar*  chars);

    void
    accumNameArray(
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    accumContentArray(
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    accumArrayUTF(
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    accumArrayUTFDirect(
            const XalanDOMChar          chars[],
            XalanDOMString::size_type   start,
            XalanDOMString::size_type   length);

    void
    accumNameDOMString(const XalanDOMString&    str);

    void
    accumContentDOMString(const XalanDOMString& str);

    void
    accumDOMStringUTF(const XalanDOMString& str);

    void
    accumDOMStringUTFDirect(const XalanDOMString&   str);

    void
    outputDocTypeDecl(const XalanDOMChar*   name);

    void
    processAttribute(
            const XalanDOMChar*     name,
            const XalanDOMChar*     value);

    void
    printSpace(int n);

    void
    accumNormalizedPIData(
            const XalanDOMChar*         theData,
            XalanDOMString::size_type   theLength);


    // Data members...
    bool        m_bytesEqualChars;

    bool        m_shouldFlush;

    bool        m_spaceBeforeClose;

    bool        m_escapeCData;

    bool        m_inEntityRef;

    const XalanDOMString    m_version;

    const XalanDOMString    m_standalone;

    const XalanDOMString    m_mediaType;

    const XalanDOMString    m_attrSpecialChars;

    typedef XalanDOMString::size_type   size_type;

    static const XalanDOMChar   s_doctypeHeaderStartString[];

    static const size_type      s_doctypeHeaderStartStringLength;

    static const XalanDOMChar   s_doctypeHeaderPublicString[];

    static const size_type      s_doctypeHeaderPublicStringLength;

    static const XalanDOMChar   s_doctypeHeaderSystemString[];

    static const size_type      s_doctypeHeaderSystemStringLength;

    static const XalanDOMChar   s_xmlHeaderStartString[];

    static const size_type      s_xmlHeaderStartStringLength;

    static const XalanDOMChar   s_xmlHeaderEncodingString[];

    static const size_type      s_xmlHeaderEncodingStringLength;

    static const XalanDOMChar   s_xmlHeaderStandaloneString[];

    static const size_type      s_xmlHeaderStandaloneStringLength;

    static const XalanDOMChar   s_xmlHeaderEndString[];

    static const size_type      s_xmlHeaderEndStringLength;

    static const XalanDOMChar   s_defaultVersionString[];

    static const size_type      s_defaultVersionStringLength;

    static const XalanDOMChar   s_xhtmlDocTypeString[];

    static const size_type      s_xhtmlDocTypeStringLength;

    static const XalanDOMChar   s_dtdCDATACloseString[];

    static const size_type      s_dtdCDATACloseStringLength;

    DOMCharBufferType                           m_charBuf;

    XalanDOMString::size_type                   m_pos;

    ByteBufferType                              m_byteBuf;

    static const XalanDOMString::size_type      s_maxBufferSize;

    BoolStackType   m_elemStack;

    AccumCharFunctionType       m_accumNameCharFunction;

    AccumStringFunctionType     m_accumNameStringFunction;

    AccumDOMStringFunctionType  m_accumNameDOMStringFunction;

    AccumArrayFunctionType      m_accumNameArrayFunction;

    AccumCharFunctionType       m_accumContentCharFunction;

    AccumStringFunctionType     m_accumContentStringFunction;

    AccumDOMStringFunctionType  m_accumContentDOMStringFunction;

    AccumArrayFunctionType      m_accumContentArrayFunction;

    FlushFunctionType           m_flushFunction;

    const XalanDOMChar*         m_newlineString;

    XalanDOMString::size_type   m_newlineStringLength;
};



XALAN_CPP_NAMESPACE_END



#endif  // FORMATTERTOXML_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.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.