public boolean isComplexType() { return (xsTypeDefinition.getTypeCategory() & XSConstants.PARTICLE) != 0; }
private int getBaseType(XSTypeDefinition std) { if (std == null) { return XQItemType.XQBASETYPE_ANYSIMPLETYPE; } if (xs_ns.equals(std.getNamespace())) { QName qn = new QName(std.getNamespace(), std.getName()); int type = getBaseTypeForTypeName(qn); logger.trace("getBaseType; returning {} for type {}", type, std.getName()); return type; } return getBaseType(std.getBaseType()); }
public boolean derivedFrom(String namespace, String name, short derivationMethod) { return xsTypeDefinition.derivedFrom(namespace, name, mapFlags(derivationMethod)); }
private QName getQName( XSTypeDefinition xsType ) { QName name = null; if ( !xsType.getAnonymous() ) { name = new QName( xsType.getNamespace(), xsType.getName() ); } return name; }
/** * Get a QName for a xs type * @param xstype * @return */ public QName getQName(XSTypeDefinition xstype) { String prefix = null; String ns = xstype.getNamespace(); String name = xstype.getName(); if (!ns.equals(xsNS)) prefix = Constants.PREFIX_TNS; else prefix = Constants.PREFIX_XSD; return new QName(ns, name, prefix); }
String generateTypeHierarchy( XSTypeDefinition type, String indent ) { String s = "\n" + indent + "-> '" + type.getName() + "' (" + type.getNamespace() + "'): "; switch ( type.getTypeCategory() ) { case XSTypeDefinition.SIMPLE_TYPE: { s += "simple"; break; } case XSTypeDefinition.COMPLEX_TYPE: { s += "complex"; break; } default: { // cannot happen } } if ( type.getBaseType() != null && type.getBaseType() != type ) { s += generateTypeHierarchy( type.getBaseType(), " " + indent ); } return s; }
/** * Create a new JBossXSTypeDefinition * while reading data from a XSTypeDefinition * * @param xt */ public JBossXSTypeDefinition(XSTypeDefinition xt) { super(xt.getName(), xt.getNamespace()); setAnonymous(xt.getAnonymous()); XSTypeDefinition xbase = xt.getBaseType(); if (xbase != null) { if (xbase instanceof JBossXSTypeDefinition == false && !("anyType".equals(xbase.getName()))) baseType = new JBossXSTypeDefinition(xbase); } }
private boolean getDBMethods(XSTypeDefinition typed, XSTypeDefinition typeb, OneSubGroup methods, short schemaVersion) { short dMethod = 0, bMethod = 0; while (typed != typeb && !SchemaGrammar.isAnyType(typed)) { if (typed.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) dMethod |= ((XSComplexTypeDecl)typed).fDerivedBy; else dMethod |= XSConstants.DERIVATION_RESTRICTION; typed = typed.getBaseType(); // type == null means the current type is anySimpleType, // whose base type should be anyType if (typed == null) typed = SchemaGrammar.getXSAnyType(schemaVersion); if (typed.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) bMethod |= ((XSComplexTypeDecl)typed).fBlock; } // No derivation relation, or blocked, return false if (typed != typeb || (dMethod & bMethod) != 0) return false; // Remember the derivation methods and blocks, return true. methods.dMethod = dMethod; methods.bMethod = bMethod; return true; }
public void printSimpleTypesSummary( String namespace ) { XSNamedMap elementMap = schema.getComponentsByNamespace( XSConstants.TYPE_DEFINITION, namespace ); SortedSet<String> simpleTypeNames = new TreeSet<String>(); for ( int i = 0; i < elementMap.getLength(); i++ ) { XSTypeDefinition typeDef = (XSTypeDefinition) elementMap.item( i ); if ( typeDef.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE ) { System.out.println( toString( ( (XSSimpleTypeDefinition) typeDef ) ) ); simpleTypeNames.add( typeDef.getName() ); } } System.out.println( simpleTypeNames.size() + " simple types in namespace: '" + namespace + "':\n" ); for ( String typeName : simpleTypeNames ) { System.out.println( typeName ); } }
for ( int i = 0; i < typeDefs.getLength(); i++ ) { XSTypeDefinition candidate = (XSTypeDefinition) typeDefs.item( i ); if ( namespace == null || namespace.equals( candidate.getNamespace() ) ) { boolean isAbstract = false; if ( candidate instanceof XSComplexTypeDefinition ) { if ( candidate.derivedFromType( typeDef, (short) ( DERIVATION_RESTRICTION | DERIVATION_EXTENSION | DERIVATION_UNION | DERIVATION_LIST ) ) ) { typeNames.add( new QName( candidate.getNamespace(), candidate.getName() ) ); XSTypeDefinition candidateBaseType = candidate.getBaseType(); if ( typeDef.getName().equals( candidateBaseType.getName() ) && typeDef.getNamespace().equals( candidateBaseType.getNamespace() ) ) { typeNames.add( new QName( candidate.getNamespace(), candidate.getName() ) );
else if (fCurrentType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) { fAppendBuffer = true; } else { XSElementDecl elemDecl = findLocallyDeclaredType(element, fCurrentCM, fTypeStack[fElementDepth-1].getBaseType()); if (elemDecl != null) { final XSTypeDefinition elemType = elemDecl.getTypeDefinition(); if (elemType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) { block |= ((XSComplexTypeDecl) elemType).fBlock; reportSchemaError( "cos-element-consistent.4.a", new Object[] { element.rawname, fCurrentType, elemType.getName()}); if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) { XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType; if (ctype.getAbstract()) { if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) { fCurrentCM = ((XSComplexTypeDecl) fCurrentType).getContentModel(fCMBuilder); if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) { XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType; attrGrp = ctype.getAttrGrp();
public String getName() { return xsTypeDefinition.getName(); }
/** * Builds the anonymous type mapping. This is intended to be called lazily. */ public void build() { XSModel model = JBossXSModel.this; anonymousTypeMap = new HashMap<String, XSTypeDefinition>(); anonymousElementMap = new HashMap<String, XSElementDeclaration>(); processed.clear(); XSNamedMap namedMap = model.getComponents(XSConstants.TYPE_DEFINITION); for (int i = 0; i < namedMap.getLength(); i++) { XSTypeDefinition type = (XSTypeDefinition)namedMap.item(i); if (type.getTypeCategory() != XSTypeDefinition.COMPLEX_TYPE) continue; analyzeComplexType((XSComplexTypeDefinition)type, null, type.getNamespace()); } namedMap = model.getComponents(XSConstants.ELEMENT_DECLARATION); for (int i = 0; i < namedMap.getLength(); i++) { XSElementDeclaration element = (XSElementDeclaration)namedMap.item(i); analyzeElement(element, null, element.getNamespace(), null, null); } processed.clear(); }
private String analyzeType(XSTypeDefinition type, String parentName, String namespace) { String name; if (type.getAnonymous()) name = ">" + parentName; else name = type.getName(); if (type.getAnonymous()) { anonymousTypeMap.put(namespace + ":" + name, type); if(log.isDebugEnabled()) log.debug("Registered as anon type: {" + namespace + ":" + name + "} -> " + type); } return name; }
/** * @see org.w3c.dom.TypeInfo#getTypeNamespace() */ public String getTypeNamespace() { if (type !=null){ return type.getNamespace(); } return null; }
private void addRelatedType(XSTypeDefinition type, Vector componentList, String namespace, Hashtable dependencies) { if (!type.getAnonymous()) { if (!SchemaSymbols.URI_SCHEMAFORSCHEMA.equals(type.getNamespace())) { //REVISIT - do we use == instead if (!componentList.contains(type)) { final Vector importedNamespaces = findDependentNamespaces(namespace, dependencies); addNamespaceDependency(namespace, type.getNamespace(), importedNamespaces); componentList.add(type); } } } else { expandRelatedTypeComponents(type, componentList, namespace, dependencies); } }
/** * Return the most specific type below xsd:anySimpleType that this type is derived from. */ private XSTypeDefinition getFoundingType() { XSTypeDefinition founding = typeDeclaration; XSTypeDefinition parent = founding.getBaseType(); if ( parent == null ) // it is xsd:anySimpleType return founding; while (parent.getBaseType() != null) { founding = parent; parent = parent.getBaseType(); } return founding; }
public void addGlobalTypeDecl(XSTypeDefinition decl, String location) { fGlobalTypeDeclsExt.put(((location!=null) ? location : "") + "," + decl.getName(), decl); if (decl.getNamespaceItem() == null) { if (decl instanceof XSComplexTypeDecl) { ((XSComplexTypeDecl) decl).setNamespaceItem(this); } else if (decl instanceof XSSimpleTypeDecl) { ((XSSimpleTypeDecl) decl).setNamespaceItem(this); } } }
XSTypeDefinition ancestorType = baseSchemaType.getBaseType(); ancestorType.derivedFrom(Constants.NS_XMLSCHEMA, SchemaSymbols.ATTVAL_ANYATOMICTYPE, XSConstants.DERIVATION_RESTRICTION))) { addAssertsFromBaseTypes(ancestorType);
public boolean derivedFromType(TypeDefinition ancestorType, short derivationMethod) { if (ancestorType instanceof XercesTypeDefinition) { XercesTypeDefinition xercesType = (XercesTypeDefinition)ancestorType; return xsTypeDefinition.derivedFromType(xercesType.xsTypeDefinition, mapFlags(derivationMethod)); } else { return xsTypeDefinition.derivedFrom(ancestorType.getNamespace(), ancestorType.getName(), mapFlags(derivationMethod)); } }