source: icXML/icXML-devel/samples/src/PSVIWriter/PSVIWriterHandlers.hpp @ 3572

Last change on this file since 3572 was 3572, checked in by nmedfort, 5 years ago

Compilation changes

File size: 13.9 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#ifndef PSVIWRITERHANDLER_HPP
19#define PSVIWRITERHANDLER_HPP
20
21// ---------------------------------------------------------------------------
22//  Includes
23// ---------------------------------------------------------------------------
24#include <xercesc/sax2/Attributes.hpp>
25#include <icxercesc/sax2/DefaultHandler.hpp>
26#include <xercesc/framework/psvi/XSConstants.hpp>
27#include <xercesc/framework/psvi/PSVIHandler.hpp>
28#include <xercesc/framework/psvi/PSVIAttribute.hpp>
29#include <xercesc/framework/psvi/PSVIAttributeList.hpp>
30#include <xercesc/framework/psvi/PSVIElement.hpp>
31#include <xercesc/framework/psvi/PSVIItem.hpp>
32#include <xercesc/framework/psvi/XSAnnotation.hpp>
33#include <xercesc/framework/psvi/XSAttributeDeclaration.hpp>
34#include <xercesc/framework/psvi/XSAttributeGroupDefinition.hpp>
35#include <xercesc/framework/psvi/XSAttributeUse.hpp>
36#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
37#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
38#include <xercesc/framework/psvi/XSFacet.hpp>
39#include <xercesc/framework/psvi/XSIDCDefinition.hpp>
40#include <xercesc/framework/psvi/XSModel.hpp>
41#include <xercesc/framework/psvi/XSModelGroup.hpp>
42#include <xercesc/framework/psvi/XSModelGroupDefinition.hpp>
43#include <xercesc/framework/psvi/XSMultiValueFacet.hpp>
44#include <xercesc/framework/psvi/XSNamedMap.hpp>
45#include <xercesc/framework/psvi/XSNamespaceItem.hpp>
46#include <xercesc/framework/psvi/XSNotationDeclaration.hpp>
47#include <xercesc/framework/psvi/XSParticle.hpp>
48#include <xercesc/framework/psvi/XSSimpleTypeDefinition.hpp>
49#include <xercesc/framework/psvi/XSTypeDefinition.hpp>
50#include <xercesc/framework/psvi/XSWildcard.hpp>
51#include <xercesc/framework/XMLFormatter.hpp>
52#include <icxercesc/framework/XMLDocumentHandler.hpp>
53#include <xercesc/dom/DOMElement.hpp>
54#include <xercesc/dom/DOMNamedNodeMap.hpp>
55#include <xercesc/util/ValueStackOf.hpp>
56#include <xercesc/util/ValueVectorOf.hpp>
57#include <xercesc/util/XMLEntityResolver.hpp>
58#include <xercesc/util/XMLResourceIdentifier.hpp>
59#include <stdlib.h>
60#include <string.h>
61
62XERCES_CPP_NAMESPACE_USE
63
64class XERCES_CPP_NAMESPACE_QUALIFIER XMLDocumentDisseminator;
65
66class AttrInfo {
67public:
68        AttrInfo(const XMLCh* pUri, const XMLCh* pName, const XMLCh* pType, const XMLCh* pValue) {
69                uri = XMLString::replicate(pUri);
70                name = XMLString::replicate(pName);
71                type = XMLString::replicate(pType);
72                value = XMLString::replicate(pValue);
73        }
74
75        ~AttrInfo() {
76                XMLString::release((XMLCh**)&uri);
77                XMLString::release((XMLCh**)&name);
78                XMLString::release((XMLCh**)&type);
79                XMLString::release((XMLCh**)&value);
80        }
81
82        const XMLCh* getUri() const {
83                return uri;
84        }
85
86        const XMLCh* getLocalName() const {
87                return name;
88        }
89
90        const XMLCh* getType() const {
91                return type;
92        }
93
94        const XMLCh* getValue() const {
95                return value;
96        }
97
98private:
99        const XMLCh* uri;
100        const XMLCh* name;
101        const XMLCh* type;
102        const XMLCh* value;
103};
104
105class PSVIWriterHandlers : public PSVIHandler, public DefaultHandler, public XMLEntityResolver {
106public:
107    // -----------------------------------------------------------------------
108    //  Constructors and Destructor
109    // -----------------------------------------------------------------------
110    PSVIWriterHandlers(XMLFormatter* outputFormatter, XMLFormatter* errorFormatter = NULL);
111    ~PSVIWriterHandlers();
112
113    friend class PSVIAdvancedHandler;
114    // -----------------------------------------------------------------------
115    //  Convenience Utility
116    // -----------------------------------------------------------------------
117        void resetPSVIFormatter(XMLFormatter* outputFormatter);
118    void resetDocument();
119
120    // -----------------------------------------------------------------------
121    //  Handlers for the SAX ContentHandler interface
122    // -----------------------------------------------------------------------
123    void startElement(const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const Attributes& attrs);
124    void endElement(const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname);
125    void startDocument();
126    void endDocument();
127    void characters(const XMLCh* const chars, const XMLSize_t length);
128    void ignorableWhitespace(const XMLCh* const chars, const XMLSize_t length);
129    void comment(const XMLCh* const chars, const XMLSize_t length);
130    void processingInstruction(const XMLCh* const target, const XMLCh* const data);
131    void startPrefixMapping(const XMLCh* const prefix, const XMLCh* const uri);
132    void endPrefixMapping(const XMLCh* const prefix);
133    InputSource* resolveEntity(XMLResourceIdentifier* resourceIdentifier);
134    InputSource* resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId);
135
136    // -----------------------------------------------------------------------
137    //  Handlers for the SAX ErrorHandler interface
138    // -----------------------------------------------------------------------
139        void warning(const SAXParseException& exc);
140    void error(const SAXParseException& exc);
141    void fatalError(const SAXParseException& exc);
142    void resetErrors();
143
144    // -----------------------------------------------------------------------
145    //  Handlers for the PSVIHandler interface
146    // -----------------------------------------------------------------------
147
148        void handleAttributesPSVI( const XMLCh* const localName,
149                                                                const XMLCh* const uri,
150                                                                PSVIAttributeList* psviAttributes );
151        void handleElementPSVI( const XMLCh* const localName,
152                                const XMLCh* const uri,
153                                PSVIElement* elementInfo );
154        void handlePartialElementPSVI( const XMLCh* const localName,
155                                   const XMLCh* const uri,
156                                   PSVIElement* elementInfo );
157private:
158    // -----------------------------------------------------------------------
159    //  Private methods
160    // -----------------------------------------------------------------------
161
162    void processAttributes(PSVIAttributeList* psviAttributes, const RefVectorOf<AttrInfo>* attributesInfo);
163    void processNamespaceAttributes(PSVIAttributeList* psviAttributes, const RefVectorOf<AttrInfo>* attributes);
164    void processAttributePSVI(PSVIAttribute* attribute);
165    void processInScopeNamespaces();
166    void processActualValue(PSVIItem*);
167    void formDateTime(XSValue*);
168
169    void processSchemaInformation(XSModel* model);
170    void processNamespaceItem(XSNamespaceItem* namespaceItem);
171    void processSchemaComponents(XSNamespaceItem* namespaceItem);
172    void processSchemaDocuments(XSNamespaceItem* namespaceItem);
173    void processSchemaAnnotations(XSAnnotationList* annotations);
174    void processSchemaErrorCode(StringList* errors);
175
176    void processTypeDefinition(XSTypeDefinition* type);
177    void processComplexTypeDefinition(XSComplexTypeDefinition* complexType);
178    void processSimpleTypeDefinition(XSSimpleTypeDefinition* simpleType);
179    void processModelGroupDefinition(XSModelGroupDefinition* modelGroup);
180    void processAttributeGroupDefinition(XSAttributeGroupDefinition* attributeGroup);
181
182    void processElementDeclaration(XSElementDeclaration* element);
183    void processAttributeDeclaration(XSAttributeDeclaration* attribute);
184    void processNotationDeclaration(XSNotationDeclaration* notation);
185
186    void processAnnotations(XSAnnotationList* annotations);
187    void processAttributeUses(XSAttributeUseList* attributeUses);
188    void processFacets(XSFacetList* facets, XSMultiValueFacetList* multiFacets);
189    void processFundamentalFacets(XSSimpleTypeDefinition* facets);
190    void processMemberTypeDefinitions(XSSimpleTypeDefinitionList* memberTypes);
191
192    void processAnnotation(XSAnnotation* annotation);
193    void processDOMElement(const XMLCh* const encloseName, DOMElement* rootElem, const XMLCh* const elementName);
194    void processDOMAttributes(DOMNamedNodeMap* attrs);
195    void processWildcard(XSWildcard* wildcard);
196    void processModelGroup(XSModelGroup* modelGroup);
197    void processParticle(XSParticle* particle);
198
199    void processAttributeWildcard(XSWildcard* wildcard);
200    void processScope(XSComplexTypeDefinition* enclosingCTD, short scope);
201    void processValueConstraint(XSConstants::VALUE_CONSTRAINT ConstraintType, const XMLCh* constraintValue);
202
203    void processIdentityConstraintDefinition(XSNamedMap<XSIDCDefinition>* identityConstraint);
204    void processFields(StringList* fields);
205    void processXPath(const XMLCh* xpath);
206
207    void processChildren();
208    void processChildrenEnd();
209
210    void processTypeDefinitionOrRef(const XMLCh* enclose, XSTypeDefinition* type);
211        void processSimpleTypeDefinitionOrRef(XSSimpleTypeDefinition* type);
212    void processAttributeDeclarationOrRef(XSAttributeDeclaration* attrDecl);
213    void processElementDeclarationOrRef(XSElementDeclaration* elemDecl);
214        void processTypeDefinitionRef(const XMLCh* enclose, XSTypeDefinition* type);
215    void processAttributeDeclarationRef(const XMLCh* enclose, XSAttributeDeclaration* attrDecl);
216    void processElementDeclarationRef(const XMLCh* enclose, XSElementDeclaration* elemDecl);
217    void sendReference(const XMLCh* elementName, XSObject* obj);
218
219    void sendElementEmpty(const XMLCh* const elementName);
220        void sendElementValueInt(const XMLCh* const elementName, int value);
221    void sendElementValue(const XMLCh* const elementName, const XMLCh* const value);
222    void sendElementValueList(const XMLCh* const elementName, const StringList* const values);
223
224        void sendIndentedElement(const XMLCh* const elementName);
225    void sendIndentedElementWithID(const XMLCh* const elementName, XSObject* obj);      //adds the ID to the attribute list before sending
226    void sendUnindentedElement(const XMLCh* const elementName);
227
228    void writeOpen(const XMLCh* const elementName);
229        void writeOpen(const XMLCh* const elementName, const StringList* const attrs);
230        void writeClose(const XMLCh* const elementName);
231        void writeValue(const XMLCh* const elementName, const XMLCh* const value);
232        void writeValue(const XMLCh* const elementName, const StringList* const values);
233        void writeEmpty(const XMLCh* const elementName, const StringList* const attrs);
234        void writeEmpty(const XMLCh* const elementName);
235    void writeString(const XMLCh* const string);
236
237    const XMLCh* translateScope(XSConstants::SCOPE scope);
238    const XMLCh* translateValueConstraint(XSConstants::VALUE_CONSTRAINT constraintKind);
239    const XMLCh* translateBlockOrFinal(short val);
240    const XMLCh* translateDerivationMethod(XSConstants::DERIVATION_TYPE derivation);
241    const XMLCh* translateProcessContents(XSWildcard::PROCESS_CONTENTS processContents);
242    const XMLCh* translateCompositor(XSModelGroup::COMPOSITOR_TYPE compositor);
243    const XMLCh* translateValidity(PSVIItem::VALIDITY_STATE validity);
244    const XMLCh* translateValidationAttempted(PSVIItem::ASSESSMENT_TYPE validation);
245    const XMLCh* translateIdConstraintCategory(XSIDCDefinition::IC_CATEGORY category);
246    const XMLCh* translateComplexContentType(XSComplexTypeDefinition::CONTENT_TYPE contentType);
247    const XMLCh* translateSimpleTypeVariety(XSSimpleTypeDefinition::VARIETY variety);
248    const XMLCh* translateOrderedFacet(XSSimpleTypeDefinition::ORDERING ordered);
249    const XMLCh* translateFacet(XSSimpleTypeDefinition::FACET facetKind);
250    const XMLCh* translateComponentType(XSConstants::COMPONENT_TYPE type);
251    const XMLCh* translateBool(bool flag);
252
253    XMLCh* createID(XSObject* obj);
254    const XMLCh* getIdName(XSObject* obj);
255    void incIndent();
256    void decIndent();
257
258protected:
259        XMLFormatter* fFormatter;
260        XMLFormatter* fErrorFormatter;
261
262        StringList* fAttrList;
263    XMLCh* fTempResult;
264    XMLCh* fIndentChars;
265    XMLCh* fBaseUri;
266
267    unsigned int fIndent;
268    unsigned int fIndentCap;
269    unsigned int fAnonNum;
270
271        RefHashTableOf<XMLCh>* fIdMap;
272    RefVectorOf<XSObject>* fDefinedIds;
273    RefArrayVectorOf<XMLCh>* fIdNames;
274    RefArrayVectorOf<XMLCh>* fObjectLocations;
275
276        RefHashTableOf<XMLCh>* fPrefixMap;
277    RefArrayVectorOf<XMLCh>* fNamespaces;
278
279        ValueVectorOf<XMLSize_t>* fNSAttributes;  //REVISIT  dont need if NSAttrs in different object
280        ValueStackOf<bool>* fElementChildren;
281
282        RefVectorOf<AttrInfo>* fAttributesInfo;
283};
284
285class PSVIAdvancedHandler: public XMLDocumentHandler {
286public:
287    PSVIAdvancedHandler(PSVIWriterHandlers* writerHandler) : XMLDocumentHandler(), fWriterHandler(writerHandler) {}
288    ~PSVIAdvancedHandler() {}
289    void docCharacters(const XMLCh* const, const XMLSize_t, const bool) {}
290    void docComment(const XMLCh* const) {}
291    void docPI(const XMLCh* const, const XMLCh* const) {}
292    void endDocument() {}
293    void endElement(const XMLElementDecl&, const unsigned int, const bool, const XMLCh* const) {}
294    void endEntityReference(const   XMLEntityDecl&) {}
295
296    void ignorableWhitespace(const XMLCh* const, const XMLSize_t, const bool) {}
297
298    void resetDocument() {}
299    void startDocument() {}
300    void startElement(const XMLElementDecl&, const unsigned int, const XMLCh* const, const RefVectorOf<XMLAttr>&
301                     ,const XMLSize_t, const bool, const bool) {}
302    void startEntityReference(const XMLEntityDecl&) {};
303
304    void XMLDecl(const XMLCh* const versionStr, const XMLCh* const encodingStr, const XMLCh* const standaloneStr, const XMLCh* const autoEncodingStr);
305   
306    virtual XERCES_CPP_NAMESPACE_QUALIFIER XMLDocumentDisseminator * createDocumentDisseminator();
307private:
308    PSVIWriterHandlers* fWriterHandler;
309};
310
311#endif
Note: See TracBrowser for help on using the repository browser.