void XSModel::addGrammarToXSModel(XSNamespaceItem* namespaceItem)
{
// Loop through top-level attribute declarations in the grammar...
RefHashTableOf<XMLAttDef>* attDeclRegistry = namespaceItem->fGrammar->getAttributeDeclRegistry();
if(attDeclRegistry) {
RefHashTableOfEnumerator<XMLAttDef> attrEnum = RefHashTableOfEnumerator<XMLAttDef> (attDeclRegistry, false, fMemoryManager);
while (attrEnum.hasMoreElements())
{
XSAttributeDeclaration* xsAttrDecl = fObjFactory->addOrFind
(
(SchemaAttDef*) &(attrEnum.nextElement()), this
);
addComponentToNamespace
(
namespaceItem, xsAttrDecl, XSConstants::ATTRIBUTE_DECLARATION - 1
);
} // end of attribute loop
}
// Loop through top-level elements in the grammar...
RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = namespaceItem->fGrammar->getElemEnumerator();
while (elemEnum.hasMoreElements())
{
SchemaElementDecl& curElem = elemEnum.nextElement();
if (curElem.getEnclosingScope() == Grammar::TOP_LEVEL_SCOPE)
{
XSElementDeclaration* xsElemDecl = fObjFactory->addOrFind
(
&curElem, this
);
addComponentToNamespace
(
namespaceItem, xsElemDecl, XSConstants::ELEMENT_DECLARATION -1
);
}
} // end of element loop
// Now loop through top-level User Defined simple type definitions in the grammar...
DVHashTable* dvHT = namespaceItem->fGrammar->getDatatypeRegistry()->getUserDefinedRegistry();
if (dvHT)
{
RefHashTableOfEnumerator<DatatypeValidator> simpleUserEnum = RefHashTableOfEnumerator<DatatypeValidator> (dvHT, false, fMemoryManager);
while (simpleUserEnum.hasMoreElements())
{
DatatypeValidator& curSimple = simpleUserEnum.nextElement();
if (!curSimple.getAnonymous())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&curSimple, this)
, XSConstants::TYPE_DEFINITION - 1
);
}
} // end of simple User loop
}
// Loop through top-level COMPLEX type definitions in the grammar...
RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = namespaceItem->fGrammar->getComplexTypeRegistry();
if(complexTypeRegistry) {
RefHashTableOfEnumerator<ComplexTypeInfo> complexEnum = RefHashTableOfEnumerator<ComplexTypeInfo> (complexTypeRegistry, false, fMemoryManager);
while (complexEnum.hasMoreElements())
{
ComplexTypeInfo& curComplex = complexEnum.nextElement();
if (!curComplex.getAnonymous())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&curComplex, this)
, XSConstants::TYPE_DEFINITION - 1
);
}
} // end of type definition loop
}
// Loop through top-level attribute group definitions in the grammar...
RefHashTableOf<XercesAttGroupInfo>* attGroupInfoRegistry = namespaceItem->fGrammar->getAttGroupInfoRegistry();
if(attGroupInfoRegistry) {
RefHashTableOfEnumerator<XercesAttGroupInfo> attrGroupEnum = RefHashTableOfEnumerator<XercesAttGroupInfo> (attGroupInfoRegistry, false, fMemoryManager);
while (attrGroupEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->createXSAttGroupDefinition
(
&(attrGroupEnum.nextElement()), this
)
, XSConstants::ATTRIBUTE_GROUP_DEFINITION - 1
);
} // end of attribute group loop
}
// Loop through top-level model group definitions in the grammar...
RefHashTableOf<XercesGroupInfo>* groupInfoRegistry = namespaceItem->fGrammar->getGroupInfoRegistry();
if(groupInfoRegistry) {
RefHashTableOfEnumerator<XercesGroupInfo> modelGroupEnum = RefHashTableOfEnumerator<XercesGroupInfo> (groupInfoRegistry, false, fMemoryManager);
while (modelGroupEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->createXSModelGroupDefinition
(
&(modelGroupEnum.nextElement()), this
)
, XSConstants::MODEL_GROUP_DEFINITION - 1
);
} // end of model group loop
}
// Loop through notations in the grammar...
NameIdPoolEnumerator<XMLNotationDecl> notationEnum = namespaceItem->fGrammar->getNotationEnumerator();
while (notationEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&(notationEnum.nextElement()), this)
, XSConstants::NOTATION_DECLARATION - 1
);
} // end of notation loop
// Loop through annotations in the grammar...
// As annotations are already created as XSAnnotations no need to create them
// or store them in the XercesToXSMap.
XSAnnotation* annot = namespaceItem->fGrammar->getAnnotation();
while (annot)
{
fXSAnnotationList->addElement(annot);
namespaceItem->fXSAnnotationList->addElement(annot);
addComponentToIdVector(annot, XSConstants::ANNOTATION -1);
annot = annot->getNext();
} // end of annotation loop
}
void process(char* const xmlFile)
{
//
// Create a Schema validator to be used for our validation work. Then create
// a SAX parser object and pass it our validator. Then, according to what
// we were told on the command line, set it to validate or not. He owns
// the validator, so we have to allocate it.
//
SAXParser parser;
parser.setValidationScheme(SAXParser::Val_Always);
parser.setDoNamespaces(true);
parser.setDoSchema(true);
parser.parse(xmlFile);
if (parser.getErrorCount())
{
XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER endl;
return;
}
if (!parser.getValidator().handlesSchema())
{
XERCES_STD_QUALIFIER cout << "\n Non schema document, no output available\n" << XERCES_STD_QUALIFIER endl;
return;
}
Grammar* rootGrammar = parser.getRootGrammar();
if (!rootGrammar || rootGrammar->getGrammarType() != Grammar::SchemaGrammarType)
{
XERCES_STD_QUALIFIER cout << "\n Non schema grammar, no output available\n" << XERCES_STD_QUALIFIER endl;
return;
}
//
// Now we will get an enumerator for the element pool from the validator
// and enumerate the elements, printing them as we go. For each element
// we get an enumerator for its attributes and print them also.
//
SchemaGrammar* grammar = (SchemaGrammar*) rootGrammar;
RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = grammar->getElemEnumerator();
if (!elemEnum.hasMoreElements())
{
XERCES_STD_QUALIFIER cout << "\nThe validator has no elements to display\n" << XERCES_STD_QUALIFIER endl;
return;
}
while(elemEnum.hasMoreElements())
{
const SchemaElementDecl& curElem = elemEnum.nextElement();
// Name
XERCES_STD_QUALIFIER cout << "Name:\t\t\t" << StrX(curElem.getFullName()) << "\n";
// Model Type
XERCES_STD_QUALIFIER cout << "Model Type:\t\t";
switch( curElem.getModelType() )
{
case SchemaElementDecl::Empty: XERCES_STD_QUALIFIER cout << "Empty"; break;
case SchemaElementDecl::Any: XERCES_STD_QUALIFIER cout << "Any"; break;
case SchemaElementDecl::Mixed_Simple: XERCES_STD_QUALIFIER cout << "Mixed_Simple"; break;
case SchemaElementDecl::Mixed_Complex: XERCES_STD_QUALIFIER cout << "Mixed_Complex"; break;
case SchemaElementDecl::Children: XERCES_STD_QUALIFIER cout << "Children"; break;
case SchemaElementDecl::Simple: XERCES_STD_QUALIFIER cout << "Simple"; break;
case SchemaElementDecl::ElementOnlyEmpty: XERCES_STD_QUALIFIER cout << "ElementOnlyEmpty"; break;
default: XERCES_STD_QUALIFIER cout << "Unknown"; break;
}
XERCES_STD_QUALIFIER cout << "\n";
// Create Reason
XERCES_STD_QUALIFIER cout << "Create Reason:\t";
switch( curElem.getCreateReason() )
{
case XMLElementDecl::NoReason: XERCES_STD_QUALIFIER cout << "Empty"; break;
case XMLElementDecl::Declared: XERCES_STD_QUALIFIER cout << "Declared"; break;
case XMLElementDecl::AttList: XERCES_STD_QUALIFIER cout << "AttList"; break;
case XMLElementDecl::InContentModel: XERCES_STD_QUALIFIER cout << "InContentModel"; break;
case XMLElementDecl::AsRootElem: XERCES_STD_QUALIFIER cout << "AsRootElem"; break;
case XMLElementDecl::JustFaultIn: XERCES_STD_QUALIFIER cout << "JustFaultIn"; break;
default: XERCES_STD_QUALIFIER cout << "Unknown"; break;
}
XERCES_STD_QUALIFIER cout << "\n";
// Content Spec Node
processContentSpecNode( curElem.getContentSpec() );
// Misc Flags
int mflags = curElem.getMiscFlags();
if( mflags !=0 )
{
XERCES_STD_QUALIFIER cout << "Misc. Flags:\t";
}
if ( mflags & SchemaSymbols::XSD_NILLABLE )
XERCES_STD_QUALIFIER cout << "Nillable ";
if ( mflags & SchemaSymbols::XSD_ABSTRACT )
XERCES_STD_QUALIFIER cout << "Abstract ";
if ( mflags & SchemaSymbols::XSD_FIXED )
XERCES_STD_QUALIFIER cout << "Fixed ";
if( mflags !=0 )
{
XERCES_STD_QUALIFIER cout << "\n";
}
// Substitution Name
SchemaElementDecl* subsGroup = curElem.getSubstitutionGroupElem();
if( subsGroup )
{
const XMLCh* uriText = parser.getURIText(subsGroup->getURI());
XERCES_STD_QUALIFIER cout << "Substitution Name:\t" << StrX(uriText)
<< "," << StrX(subsGroup->getBaseName()) << "\n";
}
// Content Model
const XMLCh* fmtCntModel = curElem.getFormattedContentModel();
if( fmtCntModel != NULL )
{
XERCES_STD_QUALIFIER cout << "Content Model:\t" << StrX(fmtCntModel) << "\n";
}
const ComplexTypeInfo* ctype = curElem.getComplexTypeInfo();
if( ctype != NULL)
{
XERCES_STD_QUALIFIER cout << "ComplexType:\n";
XERCES_STD_QUALIFIER cout << "\tTypeName:\t" << StrX(ctype->getTypeName()) << "\n";
ContentSpecNode* cSpecNode = ctype->getContentSpec();
processContentSpecNode(cSpecNode, true );
}
// Datatype
DatatypeValidator* dtValidator = curElem.getDatatypeValidator();
processDatatypeValidator( dtValidator );
// Get an enumerator for this guy's attributes if any
if ( curElem.hasAttDefs() )
{
processAttributes( curElem.getAttDefList() );
}
XERCES_STD_QUALIFIER cout << "--------------------------------------------";
XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl;
}
return;
}
