Added Xerces-C++ 3.1.2
This commit is contained in:
sippeangelo
@@ -0,0 +1,378 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id: AllContentModel.cpp 676911 2008-07-15 13:27:32Z amassari $
|
||||
*/
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Includes
|
||||
// ---------------------------------------------------------------------------
|
||||
#include <xercesc/util/Janitor.hpp>
|
||||
#include <xercesc/util/RuntimeException.hpp>
|
||||
#include <xercesc/framework/XMLElementDecl.hpp>
|
||||
#include <xercesc/framework/XMLValidator.hpp>
|
||||
#include <xercesc/validators/common/ContentSpecNode.hpp>
|
||||
#include <xercesc/validators/common/AllContentModel.hpp>
|
||||
#include <xercesc/validators/schema/SubstitutionGroupComparator.hpp>
|
||||
#include <xercesc/validators/schema/XercesElementWildcard.hpp>
|
||||
|
||||
XERCES_CPP_NAMESPACE_BEGIN
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// AllContentModel: Constructors and Destructor
|
||||
// ---------------------------------------------------------------------------
|
||||
AllContentModel::AllContentModel( ContentSpecNode* const parentContentSpec
|
||||
, const bool isMixed
|
||||
, MemoryManager* const manager) :
|
||||
fMemoryManager(manager)
|
||||
, fCount(0)
|
||||
, fChildren(0)
|
||||
, fChildOptional(0)
|
||||
, fNumRequired(0)
|
||||
, fIsMixed(isMixed)
|
||||
, fHasOptionalContent(false)
|
||||
{
|
||||
//
|
||||
// Create a vector of unsigned ints that will be filled in with the
|
||||
// ids of the child nodes. It will be expanded as needed but we give
|
||||
// it an initial capacity of 64 which should be more than enough for
|
||||
// 99% of the scenarios.
|
||||
//
|
||||
|
||||
ValueVectorOf<QName*> children(64, fMemoryManager);
|
||||
ValueVectorOf<bool> childOptional(64, fMemoryManager);
|
||||
|
||||
//
|
||||
// Get the parent element's content spec. This is the head of the tree
|
||||
// of nodes that describes the content model. We will iterate this
|
||||
// tree.
|
||||
//
|
||||
ContentSpecNode* curNode = parentContentSpec;
|
||||
if (!curNode)
|
||||
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_NoParentCSN, fMemoryManager);
|
||||
|
||||
// And now call the private recursive method that iterates the tree
|
||||
if (curNode->getType() == ContentSpecNode::All
|
||||
&& curNode->getMinOccurs() == 0) {
|
||||
fHasOptionalContent = true;
|
||||
}
|
||||
buildChildList(curNode, children, childOptional);
|
||||
|
||||
//
|
||||
// And now we know how many elements we need in our member list. So
|
||||
// fill them in.
|
||||
//
|
||||
fCount = children.size();
|
||||
fChildren = (QName**) fMemoryManager->allocate(fCount * sizeof(QName*)); //new QName*[fCount];
|
||||
fChildOptional = (bool*) fMemoryManager->allocate(fCount * sizeof(bool)); //new bool[fCount];
|
||||
for (unsigned int index = 0; index < fCount; index++) {
|
||||
fChildren[index] = new (fMemoryManager) QName(*(children.elementAt(index)));
|
||||
fChildOptional[index] = childOptional.elementAt(index);
|
||||
}
|
||||
}
|
||||
|
||||
AllContentModel::~AllContentModel()
|
||||
{
|
||||
for (XMLSize_t index = 0; index < fCount; index++)
|
||||
delete fChildren[index];
|
||||
fMemoryManager->deallocate(fChildren); //delete [] fChildren;
|
||||
fMemoryManager->deallocate(fChildOptional); //delete [] fChildOptional;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// AllContentModel: Implementation of the ContentModel virtual interface
|
||||
// ---------------------------------------------------------------------------
|
||||
//
|
||||
//Under the XML Schema mixed model,
|
||||
//the order and number of child elements appearing in an instance
|
||||
//must agree with
|
||||
//the order and number of child elements specified in the model.
|
||||
//
|
||||
bool
|
||||
AllContentModel::validateContent( QName** const children
|
||||
, XMLSize_t childCount
|
||||
, unsigned int
|
||||
, XMLSize_t* indexFailingChild
|
||||
, MemoryManager* const manager) const
|
||||
{
|
||||
// If <all> had minOccurs of zero and there are
|
||||
// no children to validate, trivially validate
|
||||
if (childCount == 0 && (fHasOptionalContent || !fNumRequired))
|
||||
return true;
|
||||
|
||||
// keep track of the required element seen
|
||||
XMLSize_t numRequiredSeen = 0;
|
||||
|
||||
if(childCount > 0)
|
||||
{
|
||||
// Check for duplicate element
|
||||
bool* elementSeen = (bool*) manager->allocate(fCount*sizeof(bool)); //new bool[fCount];
|
||||
|
||||
const ArrayJanitor<bool> jan(elementSeen, manager);
|
||||
|
||||
// initialize the array
|
||||
for (XMLSize_t i = 0; i < fCount; i++)
|
||||
elementSeen[i] = false;
|
||||
|
||||
for (XMLSize_t outIndex = 0; outIndex < childCount; outIndex++) {
|
||||
// Get the current child out of the source index
|
||||
const QName* curChild = children[outIndex];
|
||||
|
||||
// If it's PCDATA, then we just accept that
|
||||
if (fIsMixed && curChild->getURI() == XMLElementDecl::fgPCDataElemId)
|
||||
continue;
|
||||
|
||||
// And try to find it in our list
|
||||
XMLSize_t inIndex = 0;
|
||||
for (; inIndex < fCount; inIndex++)
|
||||
{
|
||||
const QName* inChild = fChildren[inIndex];
|
||||
if ((inChild->getURI() == curChild->getURI()) &&
|
||||
(XMLString::equals(inChild->getLocalPart(), curChild->getLocalPart()))) {
|
||||
// found it
|
||||
// If this element was seen already, indicate an error was
|
||||
// found at the duplicate index.
|
||||
if (elementSeen[inIndex]) {
|
||||
*indexFailingChild=outIndex;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
elementSeen[inIndex] = true;
|
||||
|
||||
if (!fChildOptional[inIndex])
|
||||
numRequiredSeen++;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// We did not find this one, so the validation failed
|
||||
if (inIndex == fCount) {
|
||||
*indexFailingChild=outIndex;
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// Were all the required elements of the <all> encountered?
|
||||
if (numRequiredSeen != fNumRequired) {
|
||||
*indexFailingChild=childCount;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Everything seems to be ok, so return success
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool AllContentModel::validateContentSpecial(QName** const children
|
||||
, XMLSize_t childCount
|
||||
, unsigned int
|
||||
, GrammarResolver* const pGrammarResolver
|
||||
, XMLStringPool* const pStringPool
|
||||
, XMLSize_t* indexFailingChild
|
||||
, MemoryManager* const manager) const
|
||||
{
|
||||
// If <all> had minOccurs of zero and there are
|
||||
// no children to validate, trivially validate
|
||||
if (childCount == 0 && (fHasOptionalContent || !fNumRequired))
|
||||
return true;
|
||||
|
||||
// keep track of the required element seen
|
||||
XMLSize_t numRequiredSeen = 0;
|
||||
|
||||
if(childCount > 0)
|
||||
{
|
||||
SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool);
|
||||
|
||||
// Check for duplicate element
|
||||
bool* elementSeen = (bool*) manager->allocate(fCount*sizeof(bool)); //new bool[fCount];
|
||||
|
||||
const ArrayJanitor<bool> jan(elementSeen, manager);
|
||||
|
||||
// initialize the array
|
||||
for (XMLSize_t i = 0; i < fCount; i++)
|
||||
elementSeen[i] = false;
|
||||
|
||||
for (XMLSize_t outIndex = 0; outIndex < childCount; outIndex++) {
|
||||
// Get the current child out of the source index
|
||||
QName* const curChild = children[outIndex];
|
||||
|
||||
// If it's PCDATA, then we just accept that
|
||||
if (fIsMixed && curChild->getURI() == XMLElementDecl::fgPCDataElemId)
|
||||
continue;
|
||||
|
||||
// And try to find it in our list
|
||||
XMLSize_t inIndex = 0;
|
||||
for (; inIndex < fCount; inIndex++)
|
||||
{
|
||||
QName* const inChild = fChildren[inIndex];
|
||||
if ( comparator.isEquivalentTo(curChild, inChild)) {
|
||||
// match
|
||||
// If this element was seen already, indicate an error was
|
||||
// found at the duplicate index.
|
||||
if (elementSeen[inIndex]) {
|
||||
*indexFailingChild=outIndex;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
elementSeen[inIndex] = true;
|
||||
|
||||
if (!fChildOptional[inIndex])
|
||||
numRequiredSeen++;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// We did not find this one, so the validation failed
|
||||
if (inIndex == fCount) {
|
||||
*indexFailingChild=outIndex;
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// Were all the required elements of the <all> encountered?
|
||||
if (numRequiredSeen != fNumRequired) {
|
||||
*indexFailingChild=childCount;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Everything seems to be ok, so return success
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
void AllContentModel::checkUniqueParticleAttribution
|
||||
(
|
||||
SchemaGrammar* const pGrammar
|
||||
, GrammarResolver* const pGrammarResolver
|
||||
, XMLStringPool* const pStringPool
|
||||
, XMLValidator* const pValidator
|
||||
, unsigned int* const pContentSpecOrgURI
|
||||
, const XMLCh* pComplexTypeName /*= 0*/
|
||||
)
|
||||
{
|
||||
SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool);
|
||||
|
||||
XMLSize_t i, j;
|
||||
|
||||
// rename back
|
||||
for (i = 0; i < fCount; i++) {
|
||||
unsigned int orgURIIndex = fChildren[i]->getURI();
|
||||
fChildren[i]->setURI(pContentSpecOrgURI[orgURIIndex]);
|
||||
}
|
||||
|
||||
// check whether there is conflict between any two leaves
|
||||
for (i = 0; i < fCount; i++) {
|
||||
for (j = i+1; j < fCount; j++) {
|
||||
// If this is text in a Schema mixed content model, skip it.
|
||||
if ( fIsMixed &&
|
||||
(( fChildren[i]->getURI() == XMLElementDecl::fgPCDataElemId) ||
|
||||
( fChildren[j]->getURI() == XMLElementDecl::fgPCDataElemId)))
|
||||
continue;
|
||||
|
||||
if (XercesElementWildcard::conflict(pGrammar,
|
||||
ContentSpecNode::Leaf,
|
||||
fChildren[i],
|
||||
ContentSpecNode::Leaf,
|
||||
fChildren[j],
|
||||
&comparator)) {
|
||||
pValidator->emitError(XMLValid::UniqueParticleAttributionFail,
|
||||
pComplexTypeName,
|
||||
fChildren[i]->getRawName(),
|
||||
fChildren[j]->getRawName());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// AllContentModel: Private helper methods
|
||||
// ---------------------------------------------------------------------------
|
||||
void
|
||||
AllContentModel::buildChildList(ContentSpecNode* const curNode
|
||||
, ValueVectorOf<QName*>& toFill
|
||||
, ValueVectorOf<bool>& toOptional)
|
||||
{
|
||||
// Get the type of spec node our current node is
|
||||
const ContentSpecNode::NodeTypes curType = curNode->getType();
|
||||
|
||||
if (curType == ContentSpecNode::All)
|
||||
{
|
||||
// Get both the child node pointers
|
||||
ContentSpecNode* leftNode = curNode->getFirst();
|
||||
ContentSpecNode* rightNode = curNode->getSecond();
|
||||
|
||||
// Recurse on the left and right nodes
|
||||
buildChildList(leftNode, toFill, toOptional);
|
||||
if(rightNode)
|
||||
buildChildList(rightNode, toFill, toOptional);
|
||||
}
|
||||
else if (curType == ContentSpecNode::Leaf)
|
||||
{
|
||||
// At leaf, add the element to list of elements permitted in the all
|
||||
toFill.addElement(curNode->getElement());
|
||||
toOptional.addElement(false);
|
||||
fNumRequired++;
|
||||
}
|
||||
else if (curType == ContentSpecNode::ZeroOrOne)
|
||||
{
|
||||
// At ZERO_OR_ONE node, subtree must be an element
|
||||
// that was specified with minOccurs=0, maxOccurs=1
|
||||
ContentSpecNode* leftNode = curNode->getFirst();
|
||||
if (leftNode->getType() != ContentSpecNode::Leaf)
|
||||
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
|
||||
|
||||
toFill.addElement(leftNode->getElement());
|
||||
toOptional.addElement(true);
|
||||
}
|
||||
// only allow ZeroOrMore when it's the father of a Loop
|
||||
else if (curType == ContentSpecNode::ZeroOrMore &&
|
||||
curNode->getFirst()!=0 &&
|
||||
curNode->getFirst()->getType()==ContentSpecNode::Loop)
|
||||
{
|
||||
ContentSpecNode* leftNode = curNode->getFirst();
|
||||
buildChildList(leftNode, toFill, toOptional);
|
||||
}
|
||||
else if (curType == ContentSpecNode::Loop)
|
||||
{
|
||||
// At leaf, add the element to list of elements permitted in the all
|
||||
int i;
|
||||
for(i=0;i<curNode->getMinOccurs();i++)
|
||||
{
|
||||
toFill.addElement(curNode->getElement());
|
||||
toOptional.addElement(false);
|
||||
fNumRequired++;
|
||||
}
|
||||
if(curNode->getMaxOccurs()!=-1)
|
||||
for(i=0;i<(curNode->getMaxOccurs() - curNode->getMinOccurs());i++)
|
||||
{
|
||||
toFill.addElement(curNode->getElement());
|
||||
toOptional.addElement(true);
|
||||
}
|
||||
}
|
||||
else
|
||||
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
|
||||
}
|
||||
|
||||
XERCES_CPP_NAMESPACE_END
|
||||
Reference in New Issue
Block a user