// ---------------------------------------------------------------------------
// SchemaElementDecl: XMLElementDecl virtual interface implementation
// ---------------------------------------------------------------------------
XMLAttDef* SchemaElementDecl::findAttr(const XMLCh* const qName
, const unsigned int uriId
, const XMLCh* const baseName
, const XMLCh* const prefix
, const LookupOpts options
, bool& wasAdded) const
{
if (fComplexTypeInfo) {
return fComplexTypeInfo->findAttr(qName, uriId, baseName, prefix, options, wasAdded);
}
else {
if (options == XMLElementDecl::AddIfNotFound) {
SchemaAttDef* retVal = 0;
// If no att list exist yet, then create one
if (!fAttDefs) {
// Use a hash modulus of 29 and tell it owns its elements
((SchemaElementDecl*)this)->fAttDefs =
new (getMemoryManager()) RefHash2KeysTableOf<SchemaAttDef>(29, true, getMemoryManager());
}
retVal = fAttDefs->get(baseName, uriId);
// Fault it in if not found and ask to add it
if (!retVal)
{
// And add a default attribute for this name
retVal = new (getMemoryManager()) SchemaAttDef
(
prefix
, baseName
, uriId
, XMLAttDef::CData
, XMLAttDef::Implied
, getMemoryManager()
);
retVal->setElemId(getId());
fAttDefs->put((void*)retVal->getAttName()->getLocalPart(), uriId, retVal);
wasAdded = true;
}
else
{
wasAdded = false;
}
return retVal;
}
else {
wasAdded = false;
return 0;
}
}
}
XSAttributeGroupDefinition*
XSObjectFactory::createXSAttGroupDefinition(XercesAttGroupInfo* const attGroupInfo,
XSModel* const xsModel)
{
XSAttributeUseList* xsAttList = 0;
XSWildcard* xsWildcard = 0;
XMLSize_t attCount = attGroupInfo->attributeCount();
if (attCount)
{
xsAttList = new (fMemoryManager) RefVectorOf<XSAttributeUse>(attCount, false, fMemoryManager);
for (XMLSize_t i=0; i < attCount; i++)
{
SchemaAttDef* attDef = attGroupInfo->attributeAt(i);
XSAttributeDeclaration* xsAttDecl = 0;
if (attDef->getBaseAttDecl())
xsAttDecl = addOrFind(attDef->getBaseAttDecl(), xsModel);
else
xsAttDecl = addOrFind(attDef, xsModel);
if (xsAttDecl && (attDef->getDefaultType() != XMLAttDef::Prohibited)) // just for sanity
{
XSAttributeUse* attUse = createXSAttributeUse(xsAttDecl, xsModel);
xsAttList->addElement(attUse);
processAttUse(attDef, attUse);
}
}
}
if (attGroupInfo->getCompleteWildCard())
xsWildcard = createXSWildcard(attGroupInfo->getCompleteWildCard(), xsModel);
XSAttributeGroupDefinition* xsObj = new (fMemoryManager) XSAttributeGroupDefinition
(
attGroupInfo
, xsAttList
, xsWildcard
, getAnnotationFromModel(xsModel, attGroupInfo)
, xsModel
, fMemoryManager
);
fDeleteVector->addElement(xsObj);
return xsObj;
}
// ---------------------------------------------------------------------------
// ComplexTypeInfo: Helper methods
// ---------------------------------------------------------------------------
XMLAttDef* ComplexTypeInfo::findAttr(const XMLCh* const
, const unsigned int uriId
, const XMLCh* const baseName
, const XMLCh* const prefix
, const XMLElementDecl::LookupOpts options
, bool& wasAdded) const
{
SchemaAttDef* retVal = 0;
// If no att list faulted in yet, then it cannot exist
if (fAttDefs)
retVal = fAttDefs->get(baseName, uriId);
// Fault it in if not found and ask to add it
if (!retVal && (options == XMLElementDecl::AddIfNotFound))
{
// Fault in the list itself if not already
if (!fAttDefs)
faultInAttDefList();
// And add a default attribute for this name
retVal = new (fMemoryManager) SchemaAttDef
(
prefix
, baseName
, uriId
, XMLAttDef::CData
, XMLAttDef::Implied
, fMemoryManager
);
retVal->setElemId(getElementId());
fAttDefs->put((void*)retVal->getAttName()->getLocalPart(), uriId, retVal);
// update and/or create fAttList
if(!fAttList)
((ComplexTypeInfo*)this)->fAttList = new (fMemoryManager) SchemaAttDefList(fAttDefs,fMemoryManager);
fAttList->addAttDef(retVal);
wasAdded = true;
}
else
{
wasAdded = false;
}
return retVal;
}
void XPathMatcher::startElement(const XMLElementDecl& elemDecl,
const unsigned int urlId,
const XMLCh* const elemPrefix,
const RefVectorOf<XMLAttr>& attrList,
const unsigned int attrCount) {
for (int i = 0; i < (int) fLocationPathSize; i++) {
// push context
int startStep = fCurrentStep[i];
fStepIndexes->elementAt(i)->push(startStep);
// try next xpath, if not matching
if ((fMatched[i] & XP_MATCHED_D) == XP_MATCHED || fNoMatchDepth[i] > 0) {
fNoMatchDepth[i]++;
continue;
}
if((fMatched[i] & XP_MATCHED_D) == XP_MATCHED_D) {
fMatched[i] = XP_MATCHED_DP;
}
// consume self::node() steps
XercesLocationPath* locPath = fLocationPaths->elementAt(i);
int stepSize = locPath->getStepSize();
while (fCurrentStep[i] < stepSize &&
locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::SELF) {
fCurrentStep[i]++;
}
if (fCurrentStep[i] == stepSize) {
fMatched[i] = XP_MATCHED;
continue;
}
// now if the current step is a descendant step, we let the next
// step do its thing; if it fails, we reset ourselves
// to look at this step for next time we're called.
// so first consume all descendants:
int descendantStep = fCurrentStep[i];
while (fCurrentStep[i] < stepSize &&
locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::DESCENDANT) {
fCurrentStep[i]++;
}
bool sawDescendant = fCurrentStep[i] > descendantStep;
if (fCurrentStep[i] == stepSize) {
fNoMatchDepth[i]++;
continue;
}
// match child::... step, if haven't consumed any self::node()
if ((fCurrentStep[i] == startStep || fCurrentStep[i] > descendantStep) &&
locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::CHILD) {
XercesStep* step = locPath->getStep(fCurrentStep[i]);
XercesNodeTest* nodeTest = step->getNodeTest();
if (nodeTest->getType() == XercesNodeTest::QNAME) {
QName elemQName(elemPrefix, elemDecl.getElementName()->getLocalPart(), urlId, fMemoryManager);
// if (!(*(nodeTest->getName()) == *(elemDecl.getElementName()))) {
if (!(*(nodeTest->getName()) == elemQName)) {
if(fCurrentStep[i] > descendantStep) {
fCurrentStep[i] = descendantStep;
continue;
}
fNoMatchDepth[i]++;
continue;
}
}
fCurrentStep[i]++;
}
if (fCurrentStep[i] == stepSize) {
if (sawDescendant) {
fCurrentStep[i] = descendantStep;
fMatched[i] = XP_MATCHED_D;
}
else {
fMatched[i] = XP_MATCHED;
}
continue;
}
// match attribute::... step
if (fCurrentStep[i] < stepSize &&
locPath->getStep(fCurrentStep[i])->getAxisType() == XercesStep::ATTRIBUTE) {
if (attrCount) {
XercesNodeTest* nodeTest = locPath->getStep(fCurrentStep[i])->getNodeTest();
for (unsigned int attrIndex = 0; attrIndex < attrCount; attrIndex++) {
const XMLAttr* curDef = attrList.elementAt(attrIndex);
if (nodeTest->getType() != XercesNodeTest::QNAME ||
(*(nodeTest->getName()) == *(curDef->getAttName()))) {
fCurrentStep[i]++;
if (fCurrentStep[i] == stepSize) {
fMatched[i] = XP_MATCHED_A;
int j=0;
for(; j<i && ((fMatched[j] & XP_MATCHED) != XP_MATCHED); j++) ;
if(j == i) {
SchemaAttDef* attDef = ((SchemaElementDecl&) elemDecl).getAttDef(curDef->getName(), curDef->getURIId());
DatatypeValidator* dv = (attDef) ? attDef->getDatatypeValidator() : 0;
matched(curDef->getValue(), dv, false);
}
}
break;
}
}
}
if ((fMatched[i] & XP_MATCHED) != XP_MATCHED) {
if(fCurrentStep[i] > descendantStep) {
fCurrentStep[i] = descendantStep;
continue;
}
fNoMatchDepth[i]++;
}
}
}
}
