Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

FormatterToXMLUnicode.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_UNICODE_HEADER_GUARD_1357924680)
00017 #define FORMATTERTOXML_UNICODE_HEADER_GUARD_1357924680
00018 
00019 
00020 // Base include file.  Must be first.
00021 #include "xalanc/XMLSupport/XMLSupportDefinitions.hpp"
00022 
00023 
00024 
00025 #include "xalanc/XMLSupport/XalanXMLSerializerBase.hpp"
00026 
00027 
00028 
00029 #include "xercesc/sax/AttributeList.hpp"
00030 
00031 
00032 
00033 #include "xalanc/PlatformSupport/DoubleSupport.hpp"
00034 #include "xalanc/PlatformSupport/XalanOutputStream.hpp"
00035 #include "xalanc/PlatformSupport/XalanUnicode.hpp"
00036 
00037 
00038 
00039 #include <xalanc/DOMSupport/DOMServices.hpp>
00040 
00041 
00042 
00043 XALAN_CPP_NAMESPACE_BEGIN
00044 
00045 
00049 template<
00050     class                           UnicodeWriter,
00051     class                           ConstantsType,
00052     class                           CharPredicate,
00053     class                           IndentHandler,
00054     FormatterListener::eXMLVersion  XMLVersion>
00055 class XALAN_XMLSUPPORT_EXPORT FormatterToXMLUnicode : public XalanXMLSerializerBase
00056 {
00057 public:
00058 
00059     typedef typename UnicodeWriter::value_type value_type;
00060 
00061     enum
00062     {
00063         eDefaultIndentAmount = 0
00064     };
00065 
00082     FormatterToXMLUnicode(
00083             MemoryManager&          theManager,
00084             Writer&                 writer,
00085             const XalanDOMString&   encoding,
00086             const XalanDOMString&   doctypeSystem = s_emptyString,
00087             const XalanDOMString&   doctypePublic = s_emptyString,
00088             bool                    xmlDecl = true,
00089             const XalanDOMString&   standalone = s_emptyString,
00090             size_type               indent = eDefaultIndentAmount) :
00091         XalanXMLSerializerBase(
00092             theManager,
00093             XMLVersion,
00094             encoding,
00095             doctypeSystem,
00096             doctypePublic,
00097             xmlDecl,
00098             standalone),
00099         m_stringBuffer(theManager),
00100         m_writer(writer, theManager),
00101         m_constants(),
00102         m_charPredicate(),
00103         m_indentHandler(m_writer , indent)
00104     {
00105     }
00106 
00107     static FormatterToXMLUnicode*
00108     create(
00109                 MemoryManagerType&      theManager,
00110                 Writer&                 writer,
00111                 const XalanDOMString&   encoding,
00112                 const XalanDOMString&   doctypeSystem = s_emptyString,
00113                 const XalanDOMString&   doctypePublic = s_emptyString,
00114                 bool                    xmlDecl = true,
00115                 const XalanDOMString&   standalone = s_emptyString,
00116                 size_type               indent = eDefaultIndentAmount)
00117     {
00118 
00119         typedef FormatterToXMLUnicode ThisType;
00120 
00121         XalanMemMgrAutoPtr<ThisType, false> theGuard( theManager , (ThisType*)theManager.allocate(sizeof(ThisType)));
00122 
00123         ThisType* theResult = theGuard.get();
00124 
00125         new (theResult) ThisType(
00126             theManager,
00127             writer,
00128             encoding,
00129             doctypeSystem,
00130             doctypePublic,
00131             xmlDecl,
00132             standalone,
00133             indent);
00134 
00135         theGuard.release();
00136 
00137         return theResult;
00138     }
00139 
00140     virtual
00141     ~FormatterToXMLUnicode()
00142     {
00143     }
00144 
00145     Writer*
00146     getWriter() const
00147     {
00148         return m_writer.getWriter();
00149     }
00150 
00151     // These are inherited from XalanXMLSerializerBase...
00152 
00153     virtual void
00154     endDocument()
00155     {
00156         m_indentHandler.setStartNewLine(true);
00157 
00158         m_indentHandler.indent();
00159 
00160         flushBuffer();
00161     }
00162 
00163     virtual void
00164     startElement(
00165             const XMLCh* const  name,
00166             AttributeList&      attrs)
00167     {
00168         generateDoctypeDecl(name);
00169     
00170         writeParentTagEnd();
00171     
00172         m_indentHandler.setPreserve(false);
00173 
00174         m_indentHandler.indent();
00175 
00176         m_indentHandler.setStartNewLine(true);
00177 
00178         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00179 
00180         writeName(name);
00181     
00182         const unsigned int  nAttrs = attrs.getLength();
00183     
00184         for (unsigned int i = 0;  i < nAttrs ;  i++)
00185         {
00186             processAttribute(attrs.getName(i), attrs.getValue(i));
00187         }
00188     
00189         // Flag the current element as not yet having any children.
00190         openElementForChildren();
00191 
00192         m_indentHandler.increaseIndent();
00193 
00194         m_indentHandler.setPrevText(false);
00195     }
00196 
00197     virtual void
00198     endElement(const XMLCh* const   name)
00199     {
00200         m_indentHandler.decreaseIndent();
00201 
00202         const bool  hasChildNodes = childNodesWereAdded();
00203     
00204         if (hasChildNodes == true) 
00205         {
00206             m_indentHandler.indent();
00207 
00208             m_writer.write(value_type(XalanUnicode::charLessThanSign));
00209             m_writer.write(value_type(XalanUnicode::charSolidus));
00210     
00211             writeName(name);
00212         }
00213         else
00214         {
00215             if(m_spaceBeforeClose == true)
00216             {
00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(XalanUnicode::charAmpersand));
00254 
00255         writeName(name);
00256 
00257         m_writer.write(value_type(XalanUnicode::charSemicolon));
00258     }
00259 
00260     virtual void
00261     comment(const XMLCh* const  data)
00262     {
00263         writeParentTagEnd();
00264 
00265         m_indentHandler.indent();
00266 
00267         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00268         m_writer.write(value_type(XalanUnicode::charExclamationMark));
00269         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00270         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00271 
00272         writeNormalizedData(data, XalanDOMString::length(data));
00273 
00274         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00275         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00276         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00277 
00278         m_indentHandler.setStartNewLine(true);
00279     }
00280 
00281     virtual const XalanDOMString&
00282     getEncoding() const
00283     {
00284         return m_constants.s_encodingString;
00285     }
00286 
00287 protected:
00288 
00289     virtual void
00290     flushBuffer()
00291     {
00292         m_writer.flushBuffer();
00293     }
00294 
00295     void
00296     writeXMLHeader()
00297     {
00298             // "<?xml version=\""
00299         m_writer.write(
00300             m_constants.s_xmlHeaderStartString,
00301             m_constants.s_xmlHeaderStartStringLength);
00302 
00303         if (length(m_version) != 0)
00304         {
00305             m_writer.write(m_version);
00306         }
00307         else
00308         {
00309             m_writer.write(
00310                 m_constants.s_defaultVersionString,
00311                 m_constants.s_defaultVersionStringLength);
00312         }
00313>00304         a>00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(XalanUnicode::charAmpersand));
00254 
00255         writeName(name);
00256 
00257         m_writer.write(value_type(XalanUnicode::charSemicolon));
00258     }
00259 
00260     virtual void
00261     comment(const XMLCh* const  data)
00262     {
00263         writeParentTagEnd();
00264 
00265         m_indentHandler.indent();
00266 
00267         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00268         m_writer.write(value_type(XalanUnicode::charExclamationMark));
00269         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00270         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00271 
00272         writeNormalizedData(data, XalanDOMString::length(data));
00273 
00274         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00275         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00276         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00277 
00278         m_indentHandler.setStartNewLine(true);
00279     }
00280 
00281     virtual const XalanDOMString&
00282     getEncoding() const
00283     {
00284         return m_constants.s_encodingString;
00285     }
00286 
00287 protected:
00288 
00289     virtual void
00290     flushBuffer()
00291     {
00292         m_writer.flushBuffer();
00293     }
00294 
00295     void
00296     writeXMLHeader()
00297     {
00298             // "<?xml version=\""
00299         m_writer.write(
00300             m_constants.s_xmlHeaderStartString,
00301             m_constants.s_xmlHeaderStartStringLength);
00302 
00303         if (length(m_version) != 0)
00304         {
00305             m_writer.write(m_version);
00306         }
00307         else
00308         {
00309             m_writer.write(
00310                 m_constants.s_defaultVersionString,
00311                 m_constants.s_defaultVersionStringLength);
00312         }
00313>00304         a>00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(XalanUnicode::charAmpersand));
00254 
00255         writeName(name);
00256 
00257         m_writer.write(value_type(XalanUnicode::charSemicolon));
00258     }
00259 
00260     virtual void
00261     comment(const XMLCh* const  data)
00262     {
00263         writeParentTagEnd();
00264 
00265         m_indentHandler.indent();
00266 
00267         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00268         m_writer.write(value_type(XalanUnicode::charExclamationMark));
00269         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00270         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00271 
00272         writeNormalizedData(data, XalanDOMString::length(data));
00273 
00274         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00275         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00276         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00277 
00278         m_indentHandler.setStartNewLine(true);
00279     }
00280 
00281     virtual const XalanDOMString&
00282     getEncoding() const
00283     {
00284         return m_constants.s_encodingString;
00285     }
00286 
00287 protected:
00288 
00289     virtual void
00290     flushBuffer()
00291     {
00292         m_writer.flushBuffer();
00293     }
00294 
00295     void
00296     writeXMLHeader()
00297     {
00298             // "<?xml version=\""
00299         m_writer.write(
00300             m_constants.s_xmlHeaderStartString,
00301             m_constants.s_xmlHeaderStartStringLength);
00302 
00303         if (length(m_version) != 0)
00304         {
00305             m_writer.write(m_version);
00306         }
00307         else
00308         {
00309             m_writer.write(
00310                 m_constants.s_defaultVersionString,
00311                 m_constants.s_defaultVersionStringLength);
00312         }
00313>00304         a>00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(XalanUnicode::charAmpersand));
00254 
00255         writeName(name);
00256 
00257         m_writer.write(value_type(XalanUnicode::charSemicolon));
00258     }
00259 
00260     virtual void
00261     comment(const XMLCh* const  data)
00262     {
00263         writeParentTagEnd();
00264 
00265         m_indentHandler.indent();
00266 
00267         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00268         m_writer.write(value_type(XalanUnicode::charExclamationMark));
00269         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00270         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00271 
00272         writeNormalizedData(data, XalanDOMString::length(data));
00273 
00274         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00275         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00276         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00277 
00278         m_indentHandler.setStartNewLine(true);
00279     }
00280 
00281     virtual const XalanDOMString&
00282     getEncoding() const
00283     {
00284         return m_constants.s_encodingString;
00285     }
00286 
00287 protected:
00288 
00289     virtual void
00290     flushBuffer()
00291     {
00292         m_writer.flushBuffer();
00293     }
00294 
00295     void
00296     writeXMLHeader()
00297     {
00298             // "<?xml version=\""
00299         m_writer.write(
00300             m_constants.s_xmlHeaderStartString,
00301             m_constants.s_xmlHeaderStartStringLength);
00302 
00303         if (length(m_version) != 0)
00304         {
00305             m_writer.write(m_version);
00306         }
00307         else
00308         {
00309             m_writer.write(
00310                 m_constants.s_defaultVersionString,
00311                 m_constants.s_defaultVersionStringLength);
00312         }
00313>00304         a>00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(XalanUnicode::charAmpersand));
00254 
00255         writeName(name);
00256 
00257         m_writer.write(value_type(XalanUnicode::charSemicolon));
00258     }
00259 
00260     virtual void
00261     comment(const XMLCh* const  data)
00262     {
00263         writeParentTagEnd();
00264 
00265         m_indentHandler.indent();
00266 
00267         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00268         m_writer.write(value_type(XalanUnicode::charExclamationMark));
00269         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00270         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00271 
00272         writeNormalizedData(data, XalanDOMString::length(data));
00273 
00274         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00275         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00276         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00277 
00278         m_indentHandler.setStartNewLine(true);
00279     }
00280 
00281     virtual const XalanDOMString&
00282     getEncoding() const
00283     {
00284         return m_constants.s_encodingString;
00285     }
00286 
00287 protected:
00288 
00289     virtual void
00290     flushBuffer()
00291     {
00292         m_writer.flushBuffer();
00293     }
00294 
00295     void
00296     writeXMLHeader()
00297     {
00298             // "<?xml version=\""
00299         m_writer.write(
00300             m_constants.s_xmlHeaderStartString,
00301             m_constants.s_xmlHeaderStartStringLength);
00302 
00303         if (length(m_version) != 0)
00304         {
00305             m_writer.write(m_version);
00306         }
00307         else
00308         {
00309             m_writer.write(
00310                 m_constants.s_defaultVersionString,
00311                 m_constants.s_defaultVersionStringLength);
00312         }
00313>00304         a>00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(XalanUnicode::charAmpersand));
00254 
00255         writeName(name);
00256 
00257         m_writer.write(value_type(XalanUnicode::charSemicolon));
00258     }
00259 
00260     virtual void
00261     comment(const XMLCh* const  data)
00262     {
00263         writeParentTagEnd();
00264 
00265         m_indentHandler.indent();
00266 
00267         m_writer.write(value_type(XalanUnicode::charLessThanSign));
00268         m_writer.write(value_type(XalanUnicode::charExclamationMark));
00269         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00270         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00271 
00272         writeNormalizedData(data, XalanDOMString::length(data));
00273 
00274         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00275         m_writer.write(value_type(XalanUnicode::charHyphenMinus));
00276         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00277 
00278         m_indentHandler.setStartNewLine(true);
00279     }
00280 
00281     virtual const XalanDOMString&
00282     getEncoding() const
00283     {
00284         return m_constants.s_encodingString;
00285     }
00286 
00287 protected:
00288 
00289     virtual void
00290     flushBuffer()
00291     {
00292         m_writer.flushBuffer();
00293     }
00294 
00295     void
00296     writeXMLHeader()
00297     {
00298             // "<?xml version=\""
00299         m_writer.write(
00300             m_constants.s_xmlHeaderStartString,
00301             m_constants.s_xmlHeaderStartStringLength);
00302 
00303         if (length(m_version) != 0)
00304         {
00305             m_writer.write(m_version);
00306         }
00307         else
00308         {
00309             m_writer.write(
00310                 m_constants.s_defaultVersionString,
00311                 m_constants.s_defaultVersionStringLength);
00312         }
00313>00304         a>00217                 m_writer.write(value_type(XalanUnicode::charSpace));
00218             }
00219     
00220             m_writer.write(value_type(XalanUnicode::charSolidus));
00221         }
00222 
00223         m_writer.write(value_type(XalanUnicode::charGreaterThanSign));
00224  
00225         if (hasChildNodes == true) 
00226         {
00227             m_indentHandler.pop_preserve();
00228         }
00229 
00230         m_indentHandler.setPrevText(false);
00231     }   
00232 
00233     virtual void
00234     charactersRaw(
00235             const XMLCh* const  chars,
00236             const unsigned int  length)
00237     {
00238         writeParentTagEnd();
00239     
00240         m_indentHandler.setPreserve(true);
00241 
00242         m_writer.write(chars, length);
00243     }
00244 
00245 
00246     virtual void
00247     entityReference(const XMLCh* const  name)
00248     {
00249         writeParentTagEnd();
00250           
00251         m_indentHandler.indent();
00252 
00253         m_writer.write(value_type(