source: icXML/icXML-devel/src/xercesc/dom/impl/DOMConfigurationImpl.cpp @ 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: 11.1 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#include "DOMConfigurationImpl.hpp"
19#include "DOMStringListImpl.hpp"
20#include <xercesc/dom/DOMErrorHandler.hpp>
21#include <icxercesc/util/XMLString.hpp>
22#include <xercesc/util/XMLUniDefs.hpp>
23#include <xercesc/dom/DOMException.hpp>
24
25XERCES_CPP_NAMESPACE_BEGIN
26
27const unsigned short DOMConfigurationImpl::fDEFAULT_VALUES = 0x2596;
28
29DOMConfigurationImpl::DOMConfigurationImpl(MemoryManager* const manager): featureValues(fDEFAULT_VALUES),
30                                              fErrorHandler(0), fSchemaType(0), fSchemaLocation(0),
31                                              fSupportedParameters(0), fMemoryManager(manager)
32{
33    fSupportedParameters=new (fMemoryManager) DOMStringListImpl(17, fMemoryManager);
34    fSupportedParameters->add(XMLUni::fgDOMErrorHandler);
35    fSupportedParameters->add(XMLUni::fgDOMSchemaType);
36    fSupportedParameters->add(XMLUni::fgDOMSchemaLocation);
37    fSupportedParameters->add(XMLUni::fgDOMCanonicalForm);
38    fSupportedParameters->add(XMLUni::fgDOMCDATASections);
39    fSupportedParameters->add(XMLUni::fgDOMComments);
40    fSupportedParameters->add(XMLUni::fgDOMDatatypeNormalization);
41    fSupportedParameters->add(XMLUni::fgDOMWRTDiscardDefaultContent);
42    fSupportedParameters->add(XMLUni::fgDOMEntities);
43    fSupportedParameters->add(XMLUni::fgDOMInfoset);
44    fSupportedParameters->add(XMLUni::fgDOMNamespaces);
45    fSupportedParameters->add(XMLUni::fgDOMNamespaceDeclarations);
46    fSupportedParameters->add(XMLUni::fgDOMNormalizeCharacters);
47    fSupportedParameters->add(XMLUni::fgDOMSplitCDATASections);
48    fSupportedParameters->add(XMLUni::fgDOMValidate);
49    fSupportedParameters->add(XMLUni::fgDOMValidateIfSchema);
50    fSupportedParameters->add(XMLUni::fgDOMElementContentWhitespace);
51}
52
53DOMConfigurationImpl::~DOMConfigurationImpl() {
54    delete fSupportedParameters;
55}
56                                       
57void DOMConfigurationImpl::setParameter(const XMLCh* name, const void* value) {
58    if(!canSetParameter(name, value)) {
59        throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, fMemoryManager);
60    }
61
62    if(XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler)==0) {
63        fErrorHandler = (DOMErrorHandler*)value;
64    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType)==0) {
65        fSchemaType = (XMLCh*)value;
66    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation)==0) {
67        fSchemaLocation = (XMLCh*)value;
68    } else {  // canSetParameter above should take care of this case
69        throw DOMException(DOMException::NOT_FOUND_ERR, 0, fMemoryManager);
70    }
71
72}
73
74void DOMConfigurationImpl::setParameter(const XMLCh* name, bool value) {
75    if(!canSetParameter(name, value)) {
76        throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, fMemoryManager);
77    }
78
79    DOMConfigurationFeature whichFlag = getFeatureFlag(name);
80    if(value) {
81        featureValues |= whichFlag;
82    } else {
83        featureValues &= ~whichFlag;
84    }
85
86}
87
88// --------------------------------------
89// Getter Methods
90// --------------------------------------
91
92const void* DOMConfigurationImpl::getParameter(const XMLCh* name) const {
93    DOMConfigurationFeature whichFlag;
94    try {
95        whichFlag = getFeatureFlag(name);
96        if(featureValues & whichFlag) {
97            return (void*)true;
98        } else {
99            return (void*)false;
100        }
101   } catch (DOMException&) {
102        // must not be a boolean parameter
103        if(XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler)==0) {
104            return fErrorHandler;
105        } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType)==0) {
106            return fSchemaType;
107        } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation)==0) {
108            return fSchemaLocation;
109        } else {
110            throw DOMException(DOMException::NOT_FOUND_ERR, 0, fMemoryManager);
111        }
112    }
113
114}
115
116// -----------------------------------------
117// Query Methods
118// -----------------------------------------
119
120bool DOMConfigurationImpl::canSetParameter(const XMLCh* name, const void* /*value*/) const {
121
122    /**
123     * canSetParameter(name, value) returns false in two conditions:
124     *  1) if a [required] feature has no supporting code, then return false in
125     *     both the true and false outcomes (This is in order to be either fully
126     *     spec compliant, or not at all)
127     *  2) if an [optional] feature has no supporting code, then return false
128     **/ 
129   
130    if(XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler)==0) {
131        return true;                               // required //
132    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType)==0) {
133        return false;                            // optional //
134    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation)==0) {
135        return false;                            // optional //
136    } 
137    return false;
138}
139
140bool DOMConfigurationImpl::canSetParameter(const XMLCh* name, bool booleanValue) const {
141    /**
142     * canSetParameter(name, value) returns false in two conditions:
143     *  1) if a [required] feature has no supporting code, then return false in
144     *     both the true and false outcomes (This is in order to be either fully
145     *     spec compliant, or not at all)
146     *  2) if an [optional] feature has no supporting code, then return false
147     **/ 
148   
149    DOMConfigurationFeature whichFlag = getFeatureFlag(name);
150    switch (whichFlag) {
151        case FEATURE_CANONICAL_FORM:
152            if(booleanValue) return false;      // optional //
153            else             return true;       // required //
154        case FEATURE_CDATA_SECTIONS:
155            return true;
156        case FEATURE_COMMENTS: 
157            return true;
158        case FEATURE_DATATYPE_NORMALIZATION: 
159            if(booleanValue) return false;       // required //
160            else             return true;        // required //
161        case FEATURE_DISCARD_DEFAULT_CONTENT: 
162            if(booleanValue) return false;       // required //
163            else             return true;        // required //
164        case FEATURE_ENTITIES: 
165            if(booleanValue) return true;       // required //
166            else             return true;       // required //
167        case FEATURE_INFOSET: 
168            if(booleanValue) return false;       // required //
169            else             return true;       // no effect//
170        case FEATURE_NAMESPACES: 
171            return true;       
172        case FEATURE_NAMESPACE_DECLARATIONS: 
173            if(booleanValue) return true;      // optional //
174            else             return false;       // required //
175        case FEATURE_NORMALIZE_CHARACTERS: 
176            if(booleanValue) return false;      // optional //
177            else             return true;       // required //
178        case FEATURE_SPLIT_CDATA_SECTIONS: 
179            //we dont report an error in the false case so we cant claim we do it
180            if(booleanValue) return false;       // required //
181            else             return false;       // required //
182        case FEATURE_VALIDATE: 
183            if(booleanValue) return false;      // optional //
184            else             return true;       // required //
185        case FEATURE_VALIDATE_IF_SCHEMA: 
186            if(booleanValue) return false;      // optional //
187            else             return true;       // required //
188         
189        case FEATURE_ELEMENT_CONTENT_WHITESPACE: 
190            if(booleanValue) return true;       // required //
191            else             return false;      // optional //
192    }
193        // should never be here
194    return false;
195}
196
197const DOMStringList* DOMConfigurationImpl::getParameterNames() const
198{
199    return fSupportedParameters;
200}
201
202// -------------------------------------------
203// Impl methods
204// -------------------------------------------
205
206DOMConfigurationImpl::DOMConfigurationFeature DOMConfigurationImpl::getFeatureFlag(const XMLCh* name) const {
207    if(XMLString::compareIStringASCII(name, XMLUni::fgDOMCanonicalForm)==0) {
208        return FEATURE_CANONICAL_FORM;
209    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCDATASections )==0) {
210        return FEATURE_CDATA_SECTIONS;
211    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMComments)==0) {
212        return FEATURE_COMMENTS;
213    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMDatatypeNormalization)==0)  {
214        return FEATURE_DATATYPE_NORMALIZATION;
215    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMWRTDiscardDefaultContent)==0) {
216        return FEATURE_DISCARD_DEFAULT_CONTENT;
217    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMEntities)==0) {
218        return FEATURE_ENTITIES;
219    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMInfoset)==0)  {
220        return FEATURE_INFOSET;
221    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaces)==0) {
222        return FEATURE_NAMESPACES;
223    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaceDeclarations)==0) {
224        return FEATURE_NAMESPACE_DECLARATIONS;
225    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNormalizeCharacters)==0) {
226        return FEATURE_NORMALIZE_CHARACTERS;
227    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSplitCDATASections)==0) {
228        return FEATURE_SPLIT_CDATA_SECTIONS;
229    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidate)==0) {
230        return FEATURE_VALIDATE;
231    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidateIfSchema)==0) {
232        return FEATURE_VALIDATE_IF_SCHEMA;
233    } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMElementContentWhitespace)==0) {
234        return FEATURE_ELEMENT_CONTENT_WHITESPACE;
235    } else {
236        throw DOMException(DOMException::NOT_FOUND_ERR, 0, fMemoryManager);
237    }
238       
239}
240
241DOMErrorHandler* DOMConfigurationImpl::getErrorHandler() const {
242    return fErrorHandler;
243}
244
245const XMLCh* DOMConfigurationImpl::getSchemaType() const {
246    return fSchemaType;
247}
248
249const XMLCh* DOMConfigurationImpl::getSchemaLocation() const {
250    return fSchemaLocation;
251}
252
253void DOMConfigurationImpl::setErrorHandler(DOMErrorHandler *erHandler) {
254    fErrorHandler = erHandler;
255}
256
257void DOMConfigurationImpl::setSchemaType(const XMLCh* st) {
258    fSchemaType = st;
259}
260
261void DOMConfigurationImpl::setSchemaLocation(const XMLCh* sl) {
262    fSchemaLocation = sl;
263}
264
265
266XERCES_CPP_NAMESPACE_END
267
268
269/**
270 * End of file DOMConfigurationImpl.cpp
271 */
Note: See TracBrowser for help on using the repository browser.