| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "DOMConfigurationImpl.hpp" |
| #include "DOMStringListImpl.hpp" |
| #include <xercesc/dom/DOMErrorHandler.hpp> |
| #include <xercesc/util/XMLString.hpp> |
| #include <xercesc/util/XMLUniDefs.hpp> |
| #include <xercesc/dom/DOMException.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| const unsigned short DOMConfigurationImpl::fDEFAULT_VALUES = 0x2596; |
| |
| DOMConfigurationImpl::DOMConfigurationImpl(MemoryManager* const manager): featureValues(fDEFAULT_VALUES), |
| fErrorHandler(0), fSchemaType(0), fSchemaLocation(0), |
| fSupportedParameters(0), fMemoryManager(manager) |
| { |
| fSupportedParameters=new (fMemoryManager) DOMStringListImpl(17, fMemoryManager); |
| fSupportedParameters->add(XMLUni::fgDOMErrorHandler); |
| fSupportedParameters->add(XMLUni::fgDOMSchemaType); |
| fSupportedParameters->add(XMLUni::fgDOMSchemaLocation); |
| fSupportedParameters->add(XMLUni::fgDOMCanonicalForm); |
| fSupportedParameters->add(XMLUni::fgDOMCDATASections); |
| fSupportedParameters->add(XMLUni::fgDOMComments); |
| fSupportedParameters->add(XMLUni::fgDOMDatatypeNormalization); |
| fSupportedParameters->add(XMLUni::fgDOMWRTDiscardDefaultContent); |
| fSupportedParameters->add(XMLUni::fgDOMEntities); |
| fSupportedParameters->add(XMLUni::fgDOMInfoset); |
| fSupportedParameters->add(XMLUni::fgDOMNamespaces); |
| fSupportedParameters->add(XMLUni::fgDOMNamespaceDeclarations); |
| fSupportedParameters->add(XMLUni::fgDOMNormalizeCharacters); |
| fSupportedParameters->add(XMLUni::fgDOMSplitCDATASections); |
| fSupportedParameters->add(XMLUni::fgDOMValidate); |
| fSupportedParameters->add(XMLUni::fgDOMValidateIfSchema); |
| fSupportedParameters->add(XMLUni::fgDOMElementContentWhitespace); |
| } |
| |
| DOMConfigurationImpl::~DOMConfigurationImpl() { |
| delete fSupportedParameters; |
| } |
| |
| void DOMConfigurationImpl::setParameter(const XMLCh* name, const void* value) { |
| if(!canSetParameter(name, value)) { |
| throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, fMemoryManager); |
| } |
| |
| if(XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler)==0) { |
| fErrorHandler = (DOMErrorHandler*)value; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType)==0) { |
| fSchemaType = (XMLCh*)value; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation)==0) { |
| fSchemaLocation = (XMLCh*)value; |
| } else { // canSetParameter above should take care of this case |
| throw DOMException(DOMException::NOT_FOUND_ERR, 0, fMemoryManager); |
| } |
| |
| } |
| |
| void DOMConfigurationImpl::setParameter(const XMLCh* name, bool value) { |
| if(!canSetParameter(name, value)) { |
| throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, fMemoryManager); |
| } |
| |
| DOMConfigurationFeature whichFlag = getFeatureFlag(name); |
| if(value) { |
| featureValues |= whichFlag; |
| } else { |
| featureValues &= ~whichFlag; |
| } |
| |
| } |
| |
| // -------------------------------------- |
| // Getter Methods |
| // -------------------------------------- |
| |
| const void* DOMConfigurationImpl::getParameter(const XMLCh* name) const { |
| DOMConfigurationFeature whichFlag; |
| try { |
| whichFlag = getFeatureFlag(name); |
| if(featureValues & whichFlag) { |
| return (void*)true; |
| } else { |
| return (void*)false; |
| } |
| } catch (DOMException&) { |
| // must not be a boolean parameter |
| if(XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler)==0) { |
| return fErrorHandler; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType)==0) { |
| return fSchemaType; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation)==0) { |
| return fSchemaLocation; |
| } else { |
| throw DOMException(DOMException::NOT_FOUND_ERR, 0, fMemoryManager); |
| } |
| } |
| |
| } |
| |
| // ----------------------------------------- |
| // Query Methods |
| // ----------------------------------------- |
| |
| bool DOMConfigurationImpl::canSetParameter(const XMLCh* name, const void* /*value*/) const { |
| |
| /** |
| * canSetParameter(name, value) returns false in two conditions: |
| * 1) if a [required] feature has no supporting code, then return false in |
| * both the true and false outcomes (This is in order to be either fully |
| * spec compliant, or not at all) |
| * 2) if an [optional] feature has no supporting code, then return false |
| **/ |
| |
| if(XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler)==0) { |
| return true; // required // |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType)==0) { |
| return false; // optional // |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation)==0) { |
| return false; // optional // |
| } |
| return false; |
| } |
| |
| bool DOMConfigurationImpl::canSetParameter(const XMLCh* name, bool booleanValue) const { |
| /** |
| * canSetParameter(name, value) returns false in two conditions: |
| * 1) if a [required] feature has no supporting code, then return false in |
| * both the true and false outcomes (This is in order to be either fully |
| * spec compliant, or not at all) |
| * 2) if an [optional] feature has no supporting code, then return false |
| **/ |
| |
| DOMConfigurationFeature whichFlag = getFeatureFlag(name); |
| switch (whichFlag) { |
| case FEATURE_CANONICAL_FORM: |
| if(booleanValue) return false; // optional // |
| else return true; // required // |
| case FEATURE_CDATA_SECTIONS: |
| return true; |
| case FEATURE_COMMENTS: |
| return true; |
| case FEATURE_DATATYPE_NORMALIZATION: |
| if(booleanValue) return false; // required // |
| else return true; // required // |
| case FEATURE_DISCARD_DEFAULT_CONTENT: |
| if(booleanValue) return false; // required // |
| else return true; // required // |
| case FEATURE_ENTITIES: |
| if(booleanValue) return true; // required // |
| else return true; // required // |
| case FEATURE_INFOSET: |
| if(booleanValue) return false; // required // |
| else return true; // no effect// |
| case FEATURE_NAMESPACES: |
| return true; |
| case FEATURE_NAMESPACE_DECLARATIONS: |
| if(booleanValue) return true; // optional // |
| else return false; // required // |
| case FEATURE_NORMALIZE_CHARACTERS: |
| if(booleanValue) return false; // optional // |
| else return true; // required // |
| case FEATURE_SPLIT_CDATA_SECTIONS: |
| //we dont report an error in the false case so we cant claim we do it |
| if(booleanValue) return false; // required // |
| else return false; // required // |
| case FEATURE_VALIDATE: |
| if(booleanValue) return false; // optional // |
| else return true; // required // |
| case FEATURE_VALIDATE_IF_SCHEMA: |
| if(booleanValue) return false; // optional // |
| else return true; // required // |
| |
| case FEATURE_ELEMENT_CONTENT_WHITESPACE: |
| if(booleanValue) return true; // required // |
| else return false; // optional // |
| } |
| // should never be here |
| return false; |
| } |
| |
| const DOMStringList* DOMConfigurationImpl::getParameterNames() const |
| { |
| return fSupportedParameters; |
| } |
| |
| // ------------------------------------------- |
| // Impl methods |
| // ------------------------------------------- |
| |
| DOMConfigurationImpl::DOMConfigurationFeature DOMConfigurationImpl::getFeatureFlag(const XMLCh* name) const { |
| if(XMLString::compareIStringASCII(name, XMLUni::fgDOMCanonicalForm)==0) { |
| return FEATURE_CANONICAL_FORM; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCDATASections )==0) { |
| return FEATURE_CDATA_SECTIONS; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMComments)==0) { |
| return FEATURE_COMMENTS; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMDatatypeNormalization)==0) { |
| return FEATURE_DATATYPE_NORMALIZATION; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMWRTDiscardDefaultContent)==0) { |
| return FEATURE_DISCARD_DEFAULT_CONTENT; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMEntities)==0) { |
| return FEATURE_ENTITIES; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMInfoset)==0) { |
| return FEATURE_INFOSET; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaces)==0) { |
| return FEATURE_NAMESPACES; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaceDeclarations)==0) { |
| return FEATURE_NAMESPACE_DECLARATIONS; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNormalizeCharacters)==0) { |
| return FEATURE_NORMALIZE_CHARACTERS; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSplitCDATASections)==0) { |
| return FEATURE_SPLIT_CDATA_SECTIONS; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidate)==0) { |
| return FEATURE_VALIDATE; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidateIfSchema)==0) { |
| return FEATURE_VALIDATE_IF_SCHEMA; |
| } else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMElementContentWhitespace)==0) { |
| return FEATURE_ELEMENT_CONTENT_WHITESPACE; |
| } else { |
| throw DOMException(DOMException::NOT_FOUND_ERR, 0, fMemoryManager); |
| } |
| |
| } |
| |
| DOMErrorHandler* DOMConfigurationImpl::getErrorHandler() const { |
| return fErrorHandler; |
| } |
| |
| const XMLCh* DOMConfigurationImpl::getSchemaType() const { |
| return fSchemaType; |
| } |
| |
| const XMLCh* DOMConfigurationImpl::getSchemaLocation() const { |
| return fSchemaLocation; |
| } |
| |
| void DOMConfigurationImpl::setErrorHandler(DOMErrorHandler *erHandler) { |
| fErrorHandler = erHandler; |
| } |
| |
| void DOMConfigurationImpl::setSchemaType(const XMLCh* st) { |
| fSchemaType = st; |
| } |
| |
| void DOMConfigurationImpl::setSchemaLocation(const XMLCh* sl) { |
| fSchemaLocation = sl; |
| } |
| |
| |
| XERCES_CPP_NAMESPACE_END |
| |
| |
| /** |
| * End of file DOMConfigurationImpl.cpp |
| */ |
