Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

Main Page | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

FormatterToXML.hpp

Go to the documentation of this file.
00001 /*
00002  * Copyright 1999-2004 The Apache Software Foundation.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #if !defined(FORMATTERTOXML_HEADER_GUARD_1357924680)
00017 #define FORMATTERTOXML_HEADER_GUARD_1357924680
00018 
00019 
00020 
00021 
00022 // Base include file.  Must be first.
00023 #include <xalanc/XMLSupport/XMLSupportDefinitions.hpp>
00024 
00025 
00026 
00027 #include <vector>
00028 
00029 
00030 
00031 #include <xalanc/XalanDOM/XalanDOMString.hpp>
00032 
00033 
00034 
00035 #include <xalanc/PlatformSupport/DOMStringHelper.hpp>
00036 #include <xalanc/PlatformSupport/XalanUnicode.hpp>
00037 
00038 
00039 
00040 // Base class header file.
00041 #include <xalanc/PlatformSupport/FormatterListener.hpp>
00042 
00043 
00044 
00045 XALAN_CPP_NAMESPACE_BEGIN
00046 
00047 
00048 
00049 class Writer;
00050 class XalanOutputStream;
00051 
00052 
00053 
00057 class XALAN_XMLSUPPORT_EXPORT FormatterToXML : public FormatterListener 
00058 {
00059 public:
00060 
00061     enum eDummy
00062     {
00063         eDefaultIndentAmount = 0
00064     };
00065 
00087     FormatterToXML(
00088             Writer&                 writer,
00089             const XalanDOMString&   version = XalanDOMString(),
00090             bool                    doIndent = false,
00091             int                     indent = eDefaultIndentAmount,
00092             const XalanDOMString&   encoding = XalanDOMString(),
00093             const XalanDOMString&   mediaType = XalanDOMString(),
00094             const XalanDOMString&   doctypeSystem = XalanDOMString(),
00095             const XalanDOMString&   doctypePublic = XalanDOMString(),
00096             bool                    xmlDecl = true,
00097             const XalanDOMString&   standalone = XalanDOMString(),
00098             eFormat                 format = OUTPUT_METHOD_XML,
00099             bool                    fBufferData = true);
00100 
00101     virtual
00102     ~FormatterToXML();
00103 
00104 
00105     // These methods are inherited from FormatterListener ...
00106 
00107     virtual void
00108     setDocumentLocator(const LocatorType* const     locator);
00109 
00110     virtual void
00111     startDocument();
00112 
00113     virtual void
00114     endDocument();
00115 
00116     virtual void
00117     startElement(
00118             const XMLCh* const  name,
00119             AttributeListType&  attrs);
00120 
00121     virtual void
00122     endElement(const XMLCh* const   name);
00123 
00124     virtual void
00125     characters(
00126             const XMLCh* const  chars,
00127             const unsigned int  length);
00128 
00129     virtual void
00130     charactersRaw(
00131             const XMLCh* const  chars,
00132             const unsigned int  length);
00133 
00134     virtual void
00135     entityReference(const XMLCh* const  name);
00136 
00137     virtual void
00138     ignorableWhitespace(
00139             const XMLCh* const  chars,
00140             const unsigned int  length);
00141 
00142     virtual void
00143     processingInstruction(
00144             const XMLCh* const  target,
00145             const XMLCh* const  data);
00146 
00147 
00148     virtual void
00149     resetDocument();
00150 
00151     virtual void
00152     comment(const XMLCh* const  data);
00153 
00154     virtual void
00155     cdata(
00156             const XMLCh* const  ch,
00157             const unsigned int  length);
00158 
00159     virtual Writer*
00160     getWriter() const;
00161 
00162     virtual const XalanDOMString&
00163     getDoctypeSystem() const;
00164 
00165     virtual const XalanDOMString&
00166     getDoctypePublic() const;
00167 
00168     virtual const XalanDOMString&
00169     getEncoding() const;
00170 
00171     virtual const XalanDOMString&
00172     getMediaType() const;
00173 
00174     virtual int
00175     getIndent() const;
00176 
00177     const XalanDOMString&
00178     getVersion() const
00179     {
00180         return m_version;
00181     }
00182 
00183     const XalanDOMString&
00184     getStandalone() const
00185     {
00186         return m_standalone;
00187     }
00188 
00189     bool
00190     getShouldWriteXMLHeader() const
00191     {
00192         return m_shouldWriteXMLHeader;
00193     }
00194 
00195     void
00196     setShouldWriteXMLHeader(bool    b)
00197     {
00198         m_shouldWriteXMLHeader = b;
00199     }
00200 
00201     bool
00202     getStripCData() const
00203     {
00204         return m_stripCData;
00205     }
00206 
00207     void
00208     setStripCData(bool  b)
00209     {
00210         m_stripCData = b;
00211     }
00212 
00213     bool
00214     getEscapeCData() const
00215     {
00216         return m_escapeCData;
00217     }
00218 
00219     void
00220     setEscapeCData(bool b)
00221     {
00222         m_escapeCData = b;
00223     }
00224 
00225     bool
00226     getDoIndent() const
00227     {
00228         return m_doIndent;
00229     }
00230 
00231     void
00232     setDoIndent(bool    value)
00233     {
00234         m_doIndent = value;
00235     }
00236 
00237     void
00238     setIndent(int   value)
00239     {
00240         m_indent = value;
00241     }
00242 
00243 #if defined(XALAN_NO_STD_NAMESPACE)
00244 #if defined(XALAN_USE_DEQUE_FOR_VECTOR_BOOL)
00245     typedef deque<bool>                 BoolVectorType;
00246 #else
00247     typedef vector<bool>                BoolStackType;
00248 #endif
00249     typedef vector<XalanDOMChar>        DOMCharBufferType;
00250     typedef vector<char>                ByteBufferType;
00251 #else
00252 #if defined(XALAN_USE_DEQUE_FOR_VECTOR_BOOL)
00253     typedef std::deque<bool>        BoolVectorType;
00254 #else
00255     typedef std::vector<bool>           BoolStackType;
00256 #endif
00257     typedef std::vector<XalanDOMChar>   DOMCharBufferType;
00258     typedef std::vector<char>           ByteBufferType;
00259 #endif
00260 
00261 protected:
00262 
00266     Writer* const               m_writer;
00267 
00271     XalanOutputStream* const    m_stream;
00272 
00276     void
00277     outputLineSep();
00278 
00279     typedef void (FormatterToXML::*AccumCharFunctionType)(XalanDOMChar);
00280 
00281     typedef void (FormatterToXML::*AccumStringFunctionType)(const XalanDOMChar*);
00282 
00283     typedef void (FormatterToXML::*AccumDOMStringFunctionType)(const XalanDOMString&);
00284 
00285     typedef void (FormatterToXML::*AccumArrayFunctionType)(
00286                         const XalanDOMChar[],
00287                         XalanDOMString::size_type,
00288                         XalanDOMString::size_type);
00289 
00290     typedef void (FormatterToXML::*FlushFunctionType)();
00291 
00301     void
00302     accumName(XalanDOMChar  ch)
00303     {
00304         assert(m_accumNameCharFunction != 0);
00305 
00306         (this->*m_accumNameCharFunction)(ch);
00307     }
00308 
00314     void
00315     accumContent(XalanDOMChar   ch)
00316     {
00317         assert(m_accumContentCharFunction != 0);
00318 
00319         (this->*m_accumContentCharFunction)(ch);
00320     }
00321 
00332     void
00333     accumName(const XalanDOMChar*   chars)
00334     {
00335         assert(m_accumNameStringFunction != 0);
00336 
00337         (this->*m_accumNameStringFunction)(chars);
00338     }
00339 
00346     void
00347     accumContent(const XalanDOMChar*    chars)
00348     {
00349         assert(m_accumContentStringFunction != 0);
00350 
00351         (this->*m_accumContentStringFunction)(chars);
00352     }
00353 
00365     void
00366     accumName(
00367             const XalanDOMChar          chars[],
00368             XalanDOMString::size_type   start,
00369             XalanDOMString::size_type   length)
00370     {
00371         assert(m_accumNameArrayFunction != 0);
00372 
00373         (this->*m_accumNameArrayFunction)(chars, start, length);
00374     }
00375 
00383     void
00384     accumContent(
00385             const XalanDOMChar          chars[],
00386             XalanDOMString::size_type   start,
00387             XalanDOMString::size_type   length)
00388     {
00389         assert(m_accumContentArrayFunction != 0);
00390 
00391         (this->*m_accumContentArrayFunction)(chars, start, length);
00392     }
00393 
00403     void
00404     accumName(const XalanDOMString&     str)
00405     {
00406         assert(m_accumNameDOMStringFunction != 0);
00407 
00408         (this->*m_accumNameDOMStringFunction)(str);
00409     }
00410 
00416     void
00417     accumContent(const XalanDOMString&  str)
00418     {
00419         assert(m_accumContentDOMStringFunction != 0);
00420 
00421         (this->*m_accumContentDOMStringFunction)(str);
00422     }
00423 
00427     XalanDOMString::size_type
00428     accumDefaultEscape(
00429             XalanDOMChar                ch,
00430             XalanDOMString::size_type   i,
00431             const XalanDOMChar          chars[],
00432             XalanDOMString::size_type   len,
00433             bool                        escLF);
00434 
00439     virtual bool
00440     accumDefaultEntity(
00441             XalanDOMChar    ch,
00442             bool            escLF);
00443 
00447     void
00448     initAttrCharsMap();
00449 
00453     void
00454     initCharsMap();
00455 
00459     void
00460     flushChars();
00461 
00465     void
00466     flushBytes();
00467 
00468     void
00469     flushWriter();
00470 
00471     void
00472     openElementForChildren();
00473 
00474     bool
00475     childNodesWereAdded();
00476 
00477     bool
00478     shouldIndent() const
00479     {
00480         return m_doIndent && (!m_ispreserve && !m_isprevtext);
00481     }
00482 
00487     void
00488     writeParentTagEnd();
00489 
00494     void
00495     indent(int  n);
00496 
00504     virtual void
00505     writeNormalizedChars(
00506             const XalanDOMChar          ch[],
00507             XalanDOMString::size_type   start,
00508             XalanDOMString::size_type   length,
00509             bool                        isCData);
00510 
00516     void
00517     writeNumberedEntityReference(unsigned long  theNumber);
00518 
00525     virtual void
00526     writeAttrString(
00527             const XalanDOMChar*         theString,
00528             XalanDOMString::size_type   theStringLength);
00529 
00534     virtual void
00535     accumCommentData(const XalanDOMChar*    data);
00536 
00542     static void
00543     throwInvalidUTF16SurrogateException(XalanDOMChar    ch);
00544 
00551     static void
00552     throwInvalidUTF16SurrogateException(
00553             XalanDOMChar    ch,
00554             XalanDOMChar    next);
00555 
00556     static bool
00557     isUTF16Surrogate(XalanDOMChar   ch)
00558     {
00559         return (ch & 0xFC00) == 0xD800 ? true : false;
00560     }
00561 
00562     enum eDummyTwo { SPECIALSSIZE = 256};
00563 
00568     XalanDOMChar            m_maxCharacter;
00569 
00570     XalanDOMChar            m_attrCharsMap[SPECIALSSIZE];
00571 
00572     XalanDOMChar            m_charsMap[SPECIALSSIZE];
00573 
00577     bool        m_shouldWriteXMLHeader;
00578 
00583     bool        m_ispreserve;
00584 
00588     bool        m_doIndent;
00589 
00593     bool        m_startNewLine;
00594   
00600     bool        m_needToOutputDocTypeDecl;
00601   
00606     bool        m_isprevtext;
00607 
00612     bool        m_stripCData;
00613 
00617     bool        m_nextIsRaw;
00618 
00622     bool        m_inCData;
00623 
00628     bool        m_encodingIsUTF;
00629 
00633     const XalanDOMString    m_doctypeSystem;
00634 
00638     const XalanDOMString    m_doctypePublic;
00639 
00643     XalanDOMString  m_encoding;
00644 
00648     int     m_currentIndent;
00649   
00653     int     m_indent;
00654 
00659     BoolStackType   m_preserves;
00660 
00661     // A text buffer.  We use it mostly for converting
00662     // to string values.  See uses of UnsignedLongToString()
00663     // and UnsignedLongToHexString().
00664     XalanDOMString  m_stringBuffer;
00665 
00666 private:
00667 
00668     // These are not implemented.
00669     FormatterToXML(const FormatterToXML&);
00670 
00671     FormatterToXML&
00672     operator=(const FormatterToXML&);
00673 
00674     bool
00675     operator==(const FormatterToXML&) const;
00676 
00685     void
00686     accumNameAsByte(XalanDOMChar    ch);
00687 
00696     void
00697     accumNameAsByteDirect(XalanDOMChar  ch);
00698 
00706     void
00707     accumContentAsByte(XalanDOMChar     ch);
00708 
00716     void
00717     accumContentAsByteDirect(XalanDOMChar   ch);
00718 
00727     void
00728     accumNameAsChar(XalanDOMChar    ch);
00729 
00738     void
00739     accumNameAsCharDirect(XalanDOMChar  ch);
00740 
00746     void
00747     accumContentAsChar(XalanDOMChar     ch);
00748 
00754     void
00755     accumContentAsCharDirect(XalanDOMChar   ch);
00756 
00764     void
00765     accumCharUTF(XalanDOMChar   ch);
00766 
00774     void
00775     accumCharUTFDirect(XalanDOMChar ch);
00776 
00785     void
00786     accumNameString(const XalanDOMChar* chars);
00787 
00795     void
00796     accumStringUTF(const XalanDOMChar*  chars);
00797 
00805     void
00806     accumStringUTFDirect(const XalanDOMChar*    chars);
00807 
00815     void
00816     accumContentString(const XalanDOMChar*  chars);
00817 
00827     void
00828     accumNameArray(
00829             const XalanDOMChar          chars[],
00830             XalanDOMString::size_type   start,
00831             XalanDOMString::size_type   length);
00832 
00842     void
00843     accumContentArray(
00844             const XalanDOMChar          chars[],
00845             XalanDOMString::size_type   start,
00846             XalanDOMString::size_type   length);
00847 
00857     void
00858     accumArrayUTF(
00859             const XalanDOMChar          chars[],
00860             XalanDOMString::size_type   start,
00861             XalanDOMString::size_type   length);
00862 
00872     void
00873     accumArrayUTFDirect(
00874             const XalanDOMChar          chars[],
00875             XalanDOMString::size_type   start,
00876             XalanDOMString::size_type   length);
00877 
00885     void
00886     accumNameDOMString(const XalanDOMString&    str);
00887 
00895     void
00896     accumContentDOMString(const XalanDOMString& str);
00897 
00905     void
00906     accumDOMStringUTF(const XalanDOMString& str);
00907 
00915     void
00916     accumDOMStringUTFDirect(const XalanDOMString&   str);
00917 
00923     void
00924     outputDocTypeDecl(const XalanDOMChar*   name);
00925 
00931     void
00932     processAttribute(
00933             const XalanDOMChar*     name,
00934             const XalanDOMChar*     value);
00935 
00940     void
00941     printSpace(int n);
00942 
00948     void
00949     accumNormalizedPIData(
00950             const XalanDOMChar*         theData,
00951             XalanDOMString::size_type   theLength);
00952 
00953 
00954     // Data members...
00958     bool        m_bytesEqualChars;
00959 
00960     bool        m_shouldFlush;
00961 
00965     bool        m_spaceBeforeClose;
00966 
00972     bool        m_escapeCData;
00973 
00977     bool        m_inEntityRef;
00978 
00982     const XalanDOMString    m_version;
00983 
00987     const XalanDOMString    m_standalone;
00988 
00992     const XalanDOMString    m_mediaType;
00993 
00997     const XalanDOMString    m_attrSpecialChars;
00998 
00999     typedef XalanDOMString::size_type   size_type;
01000 
01004     static const XalanDOMChar   s_doctypeHeaderStartString[];
01005 
01006     static const size_type      s_doctypeHeaderStartStringLength;
01007 
01011     static const XalanDOMChar   s_doctypeHeaderPublicString[];
01012 
01013     static const size_type      s_doctypeHeaderPublicStringLength;
01014 
01018     static const XalanDOMChar   s_doctypeHeaderSystemString[];
01019 
01020     static const size_type      s_doctypeHeaderSystemStringLength;
01021 
01025     static const XalanDOMChar   s_xmlHeaderStartString[];
01026 
01027     static const size_type      s_xmlHeaderStartStringLength;
01028 
01032     static const XalanDOMChar   s_xmlHeaderEncodingString[];
01033 
01034     static const size_type      s_xmlHeaderEncodingStringLength;
01035 
01039     static const XalanDOMChar   s_xmlHeaderStandaloneString[];
01040 
01041     static const size_type      s_xmlHeaderStandaloneStringLength;
01042 
01046     static const XalanDOMChar   s_xmlHeaderEndString[];
01047 
01048     static const size_type      s_xmlHeaderEndStringLength;
01049 
01053     static const XalanDOMChar   s_defaultVersionString[];
01054 
01055     static const size_type      s_defaultVersionStringLength;
01056 
01060     static const XalanDOMChar   s_xhtmlDocTypeString[];
01061 
01062     static const size_type      s_xhtmlDocTypeStringLength;
01063 
01067     static const XalanDOMChar   s_dtdCDATACloseString[];
01068 
01069     static const size_type      s_dtdCDATACloseStringLength;
01070 
01071     DOMCharBufferType                           m_charBuf;
01072 
01073     XalanDOMString::size_type                   m_pos;
01074 
01075     ByteBufferType                              m_byteBuf;
01076 
01077     static const XalanDOMString::size_type      s_maxBufferSize;
01078 
01083     BoolStackType   m_elemStack;
01084 
01089     AccumCharFunctionType       m_accumNameCharFunction;
01090 
01095     AccumStringFunctionType     m_accumNameStringFunction;
01096 
01101     AccumDOMStringFunctionType  m_accumNameDOMStringFunction;
01102 
01107     AccumArrayFunctionType      m_accumNameArrayFunction;
01108 
01113     AccumCharFunctionType       m_accumContentCharFunction;
01114 
01119     AccumStringFunctionType     m_accumContentStringFunction;
01120 
01125     AccumDOMStringFunctionType  m_accumContentDOMStringFunction;
01126 
01131     AccumArrayFunctionType      m_accumContentArrayFunction;
01132 
01136     FlushFunctionType           m_flushFunction;
01137 
01141     const XalanDOMChar*         m_newlineString;
01142 
01146     XalanDOMString::size_type   m_newlineStringLength;
01147 };
01148 
01149 
01150 
01151 XALAN_CPP_NAMESPACE_END
01152 
01153 
01154 
01155 #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.8
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.