sippeangelo
379 lines
14 KiB
C++
379 lines
14 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.
|
|
*/
|
|
|
|
/*
|
|
* $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
|