| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xerces" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache\@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation, and was |
| * originally based on software copyright (c) 1999, International |
| * Business Machines, Inc., http://www.ibm.com . For more information |
| * on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| /** |
| * $Log$ |
| * Revision 1.1 1999/11/09 01:03:43 twl |
| * Initial revision |
| * |
| * Revision 1.3 1999/11/08 20:45:43 rahul |
| * Swat for adding in Product name and CVS comment log variable. |
| * |
| */ |
| |
| |
| // --------------------------------------------------------------------------- |
| // Includes |
| // --------------------------------------------------------------------------- |
| #include <memory.h> |
| #include <string.h> |
| #include <util/RuntimeException.hpp> |
| #include <framework/XMLElementDecl.hpp> |
| #include <framework/XMLValidator.hpp> |
| #include <validators/DTD/ContentSpecNode.hpp> |
| #include <validators/DTD/DTDElementDecl.hpp> |
| #include <validators/DTD/MixedContentModel.hpp> |
| #include <validators/DTD/CMStateSet.hpp> |
| |
| |
| // --------------------------------------------------------------------------- |
| // MixedContentModel: Constructors and Destructor |
| // --------------------------------------------------------------------------- |
| MixedContentModel::MixedContentModel(const DTDElementDecl& parentElem) |
| { |
| // |
| // 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<unsigned int> childIds(64); |
| |
| // |
| // 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. |
| // |
| const ContentSpecNode* curNode = parentElem.getContentSpec(); |
| if (!curNode) |
| { |
| // <TBD> This is an error |
| } |
| |
| // And now call the private recursive method that iterates the tree |
| buildChildList(*curNode, childIds); |
| |
| // |
| // And now we know how many elements we need in our member list. So |
| // fill them in. |
| // |
| fCount = childIds.size(); |
| fChildIds = new unsigned int[fCount]; |
| memcpy(fChildIds, childIds.rawData(), fCount * sizeof(unsigned int)); |
| } |
| |
| |
| MixedContentModel::~MixedContentModel() |
| { |
| delete [] fChildIds; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // MixedContentModel: Getter methods |
| // --------------------------------------------------------------------------- |
| bool MixedContentModel::hasDups() const |
| { |
| // Can't have dups if only one child |
| if (fCount == 1) |
| return false; |
| |
| for (unsigned int index = 0; index < fCount; index++) |
| { |
| const unsigned int curVal = fChildIds[index]; |
| for (unsigned int iIndex = 0; iIndex < fCount; iIndex++) |
| { |
| if (iIndex == index) |
| continue; |
| |
| if (curVal == fChildIds[iIndex]) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // MixedContentModel: Implementation of the ContentModel virtual interface |
| // --------------------------------------------------------------------------- |
| bool MixedContentModel::getIsAmbiguous() const |
| { |
| if (fCount < 2) |
| return false; |
| |
| unsigned int index; |
| |
| // |
| // Run through the children and remember the min and max element ids. |
| // These will be used to create a bit set that will map to element ids |
| // (adjusted by the min value.) |
| // |
| // Note that we skip the 0th element because its the PCDATA one. |
| // |
| unsigned int minId = 0xFFFFFFFF; |
| unsigned int maxId = 0; |
| for (index = 1; index < fCount; index++) |
| { |
| const unsigned int curId = fChildIds[index]; |
| if (curId < minId) |
| minId = curId; |
| |
| if (curId > maxId) |
| maxId = curId; |
| } |
| |
| // |
| // Ok, now we can create a range value that represents the spread |
| // between the min/max element value. |
| // |
| // With this number we can create a state set that has a bit per |
| // possible entry in the leaf array. |
| // |
| const unsigned int idRange = (maxId - minId) + 1; |
| CMStateSet idSet(idRange); |
| |
| for (index = 1; index < fCount; index++) |
| { |
| const unsigned int adjustedId = fChildIds[index] - minId; |
| if (idSet.getBit(adjustedId)) |
| return true; |
| idSet.setBit(adjustedId); |
| } |
| return false; |
| } |
| |
| int |
| MixedContentModel::validateContent( const unsigned int* childIds |
| , const unsigned int childCount) const |
| { |
| // Use an outer index to search the passed list of children |
| for (unsigned int outIndex = 0; outIndex < childCount; outIndex++) |
| { |
| // Get the current child out of the source index |
| const unsigned int curChild = childIds[outIndex]; |
| |
| // If its PCDATA, then we just accept that |
| if (curChild == XMLElementDecl::fgPCDataElemId) |
| continue; |
| |
| // Otherwise try to find it in our list using an inner index |
| unsigned int inIndex = 0; |
| for (; inIndex < fCount; inIndex++) |
| { |
| if (curChild == fChildIds[inIndex]) |
| break; |
| } |
| |
| // |
| // We did not find this one, so the validation failed. We return |
| // the outer index, which is the index of the child that failed. |
| // |
| if (inIndex == fCount) |
| return outIndex; |
| } |
| |
| // Return success |
| return XMLValidator::Success; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // MixedContentModel: Private helper methods |
| // --------------------------------------------------------------------------- |
| void |
| MixedContentModel::buildChildList( const ContentSpecNode& curNode |
| , ValueVectorOf<unsigned int>& toFill) |
| { |
| // 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) |
| { |
| toFill.addElement(curNode.getElemId()); |
| return; |
| } |
| |
| // Get both the child node pointers |
| const ContentSpecNode* leftNode = curNode.getFirst(); |
| const ContentSpecNode* rightNode = curNode.getSecond(); |
| |
| // And recurse according to the type of node |
| if ((curType == ContentSpecNode::Choice) |
| || (curType == ContentSpecNode::Sequence)) |
| { |
| // Recurse on the left and right nodes |
| buildChildList(*leftNode, toFill); |
| |
| // The last node of a choice or sequence has a null right |
| if (rightNode) |
| buildChildList(*rightNode, toFill); |
| } |
| else if ((curType == ContentSpecNode::OneOrMore) |
| || (curType == ContentSpecNode::ZeroOrOne) |
| || (curType == ContentSpecNode::ZeroOrMore)) |
| { |
| // Just do the left node on this one |
| buildChildList(*leftNode, toFill); |
| } |
| } |
