// ---------------------------------------------------------------------------
// MixedContentModel: Private helper methods
// ---------------------------------------------------------------------------
void
MixedContentModel::buildChildList( ContentSpecNode* const curNode
, ValueVectorOf<QName*>& toFill
, ValueVectorOf<ContentSpecNode::NodeTypes>& toType)
{
// Get the type of spec node our current node is
const ContentSpecNode::NodeTypes curType = curNode->getType();
// If its a leaf, then store its id in the target list
if ((curType == ContentSpecNode::Leaf) ||
(curType == ContentSpecNode::Any) ||
(curType == ContentSpecNode::Any_Other) ||
(curType == ContentSpecNode::Any_NS) )
{
toFill.addElement(curNode->getElement());
toType.addElement(curType);
return;
}
// Get both the child node pointers
ContentSpecNode* leftNode = curNode->getFirst();
ContentSpecNode* rightNode = curNode->getSecond();
// And recurse according to the type of node
if (((curType & 0x0f) == ContentSpecNode::Choice)
|| ((curType & 0x0f) == ContentSpecNode::Sequence))
{
// Recurse on the left and right nodes
buildChildList(leftNode, toFill, toType);
// The last node of a choice or sequence has a null right
if (rightNode)
buildChildList(rightNode, toFill, toType);
}
else if ((curType == ContentSpecNode::OneOrMore)
|| (curType == ContentSpecNode::ZeroOrOne)
|| (curType == ContentSpecNode::ZeroOrMore))
{
// Just do the left node on this one
buildChildList(leftNode, toFill, toType);
}
}
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);
}
}
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// MixedContentModel: Constructors and Destructor
// ---------------------------------------------------------------------------
MixedContentModel::MixedContentModel(const bool dtd
, ContentSpecNode* const parentContentSpec
, const bool ordered
, MemoryManager* const manager) :
fCount(0)
, fChildren(0)
, fChildTypes(0)
, fOrdered(ordered)
, fDTD(dtd)
, fMemoryManager(manager)
{
//
// 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<ContentSpecNode::NodeTypes> childTypes(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
buildChildList(curNode, children, childTypes);
//
// 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];
fChildTypes = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
(
fCount * sizeof(ContentSpecNode::NodeTypes)
); //new ContentSpecNode::NodeTypes[fCount];
for (unsigned int index = 0; index < fCount; index++) {
fChildren[index] = new (fMemoryManager) QName(*children.elementAt(index));
fChildTypes[index] = childTypes.elementAt(index);
}
}
// ---------------------------------------------------------------------------
// 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);
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);
}
else
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
}
