source: icXML/icXML-devel/src/xercesc/dom/impl/DOMLSSerializerImpl.hpp @ 2722

Last change on this file since 2722 was 2722, checked in by cameron, 6 years ago

Original Xerces files with import mods for icxercesc

File size: 8.3 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: DOMLSSerializerImpl.hpp 695856 2008-09-16 12:52:32Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_DOMLSSERIALIZERMPL_HPP)
23#define XERCESC_INCLUDE_GUARD_DOMLSSERIALIZERMPL_HPP
24
25#include <xercesc/dom/DOM.hpp>
26#include <xercesc/dom/DOMLSSerializer.hpp>
27#include <xercesc/util/XMLDOMMsg.hpp>
28#include <icxercesc/util/RefHashTableOf.hpp>
29#include <xercesc/util/RefVectorOf.hpp>
30#include <xercesc/framework/XMLFormatter.hpp>
31
32XERCES_CPP_NAMESPACE_BEGIN
33
34class DOMStringListImpl;
35
36class CDOM_EXPORT DOMLSSerializerImpl : public XMemory,
37                                        public DOMLSSerializer,
38                                        public DOMConfiguration
39{
40
41public:
42
43    /** @name Constructor and Destructor */
44    //@{
45
46    /**
47     * Constructor.
48     */
49    DOMLSSerializerImpl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
50
51    /**
52     * Destructor.
53     */
54    ~DOMLSSerializerImpl();
55    //@}
56
57    /** @name Implementation of DOMLSSerializer interface */
58    //@{
59
60    virtual DOMConfiguration*       getDomConfig();
61
62    virtual void                    setNewLine(const XMLCh* const newLine);
63    virtual const XMLCh*            getNewLine() const;
64
65    virtual void                    setFilter(DOMLSSerializerFilter *filter);
66    virtual DOMLSSerializerFilter*  getFilter() const;
67
68    virtual bool                    write(const DOMNode*        nodeToWrite,
69                                          DOMLSOutput* const    destination);
70    virtual bool                    writeToURI(const DOMNode*   nodeToWrite,
71                                               const XMLCh*     uri);
72    /**
73          *  The caller is responsible for the release of the returned string
74          */
75    virtual XMLCh*                  writeToString(const DOMNode* nodeToWrite, MemoryManager* manager = NULL);
76    virtual void                    release();
77
78    //@}
79
80    /** @name Implementation of DOMConfiguration interface */
81    //@{
82    virtual void setParameter(const XMLCh* name, const void* value);
83    virtual void setParameter(const XMLCh* name, bool value);
84    virtual const void* getParameter(const XMLCh* name) const;
85    virtual bool canSetParameter(const XMLCh* name, const void* value) const;
86    virtual bool canSetParameter(const XMLCh* name, bool value) const;
87    virtual const DOMStringList* getParameterNames() const;
88    //@}
89
90private:
91
92    /** unimplemented copy ctor and assignment operator */
93    DOMLSSerializerImpl(const DOMLSSerializerImpl&);
94    DOMLSSerializerImpl & operator = (const DOMLSSerializerImpl&);
95
96protected:
97    /** helper **/
98    void                          processNode(const DOMNode* const);
99
100    void                          procCdataSection(const XMLCh*   const nodeValue
101                                                 , const DOMNode* const nodeToWrite);
102
103    void                          procUnrepCharInCdataSection(const XMLCh*   const nodeValue
104                                                            , const DOMNode* const nodeToWrite);
105
106protected:
107    /**
108     * Overidden by derived classes to extend the abilities of the standard writer
109     * always returns false in the default implementation
110     * @return true if the method deals with nodeToWrite
111     */
112    virtual bool                          customNodeSerialize(const DOMNode* const nodeToWrite, int level);
113
114    DOMNodeFilter::FilterAction   checkFilter(const DOMNode* const) const;
115
116    bool                          checkFeature(const XMLCh* const featName
117                                             , bool               state
118                                             , int&               featureId) const;
119
120    bool                          reportError(const DOMNode* const    errorNode
121                                            , DOMError::ErrorSeverity errorType
122                                            , const XMLCh*   const    errorMsg);
123    bool                          reportError(const DOMNode* const    errorNode
124                                            , DOMError::ErrorSeverity errorType
125                                            , XMLDOMMsg::Codes        toEmit);
126
127    bool                          canSetFeature(const int featureId
128                                              , bool      val)     const;
129    void                          setFeature(const int featureId
130                                           , bool      val);
131    bool                          getFeature(const int featureId) const;
132
133    void                          printNewLine();
134    void                          setURCharRef();
135    bool                          isDefaultNamespacePrefixDeclared() const;
136    bool                          isNamespaceBindingActive(const XMLCh* prefix, const XMLCh* uri) const;
137
138
139    void printIndent(unsigned int level);
140    //does the actual work for processNode while keeping track of the level
141    void processNode(const DOMNode* const nodeToWrite, int level);
142
143    void processBOM();
144
145    // -----------------------------------------------------------------------
146    //  Private data members
147    //
148    //  fFeatures
149    //
150    //  fNewLine
151    //      own it
152    //
153    //  fErrorHandler
154    //      don't own it
155    //
156    //  fFilter
157    //      don't own it
158    //
159    //  fDocumentVersion
160    //      The XML Version of the document to be serialized.
161    //
162    //  fSupportedParameters
163    //      A list of the parameters that can be set, including the ones
164    //      specific of Xerces
165    //
166    //  fEncodingUsed (session var)
167    //      the actual encoding used in write(),
168    //      it does not own any data(memory).
169    //
170    //  fNewLineUsed (session var)
171    //      the actual "end of line" sequence used in write(),
172    //      it does not own any data(memory).
173    //
174    //  fFormatter (session var)
175    //      the formatter used in write()
176    //
177    //  fErrorCount
178    //      the count of error encountered in the serialization,
179    //      which neither the error handler, nor the serializer itself,
180    //      treat as fatal. And the serializer will return true/false
181    //      based on this value.
182    //
183    //  fCurrentLine
184    //      the current line. Used to track the line number the current
185    //      node begins on
186    //
187    // -----------------------------------------------------------------------
188
189    int                           fFeatures;
190    XMLCh                        *fNewLine;
191    DOMErrorHandler              *fErrorHandler;
192    DOMLSSerializerFilter        *fFilter;
193    const XMLCh                  *fDocumentVersion;
194    DOMStringListImpl            *fSupportedParameters;
195
196    //session vars
197    const XMLCh                  *fEncodingUsed;
198    const XMLCh                  *fNewLineUsed;
199    XMLFormatter                 *fFormatter;
200    int                           fErrorCount;
201    int                           fCurrentLine;
202    bool                          fLineFeedInTextNodePrinted;
203    unsigned int                  fLastWhiteSpaceInTextNode;
204
205    RefVectorOf< RefHashTableOf<XMLCh> >* fNamespaceStack;
206    MemoryManager*               fMemoryManager;
207};
208
209inline DOMConfiguration* DOMLSSerializerImpl::getDomConfig()
210{
211    return this;
212}
213
214inline void DOMLSSerializerImpl::setFeature(const int featureId
215                                    , bool      val)
216{
217    (val)? fFeatures |= (1<<featureId) : fFeatures &= ~(1<<featureId);
218}
219
220inline bool DOMLSSerializerImpl::getFeature(const int featureId) const
221{
222    return ((fFeatures & ( 1<<featureId )) != 0) ? true : false;
223}
224
225inline void DOMLSSerializerImpl::setURCharRef()
226{
227    fFormatter->setUnRepFlags(XMLFormatter::UnRep_CharRef);
228}
229
230XERCES_CPP_NAMESPACE_END
231
232#endif
Note: See TracBrowser for help on using the repository browser.