sippeangelo
272 lines
11 KiB
C++
272 lines
11 KiB
C++
/*
|
|
* 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
|
|
*/
|