public String getName() { return xsTypeDefinition.getName(); }
/** * 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); }
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); } } }
private QName getQName( XSTypeDefinition xsType ) { QName name = null; if ( !xsType.getAnonymous() ) { name = new QName( xsType.getNamespace(), xsType.getName() ); } return name; }
/** * Delete a XSTypeDefinition * * @param xst */ public void removeXSTypeDefinition(XSTypeDefinition xst) { String name = xst.getName(); types.remove(name); }
/** * Get formatted string for the qname representing the xstype * @param xstype * @return */ public String getFormattedString(XSTypeDefinition xstype) { String ns = xstype.getNamespace(); String name = xstype.getName(); if (!ns.equals(xsNS)) name = getPrefix(ns) + ":" + name; return name; }
/** * Add an XSTypeDefinition * @param xsType */ public void addXSTypeDefinition(XSTypeDefinition xsType) { if(xsType == null) throw NativeMessages.MESSAGES.illegalNullArgument("xsType"); String xsTypeName = xsType.getName(); types.put(xsTypeName,xsType); }
void addGlobalTypeDecl(XSTypeDefinition decl) { final String namespace = decl.getNamespace(); final String declKey = (namespace == null || namespace.length() == 0) ? "," + decl.getName() : namespace + "," + decl.getName(); if (fGlobalTypeDecls.get(declKey) == null) { fGlobalTypeDecls.put(declKey, decl); } }
void appendTypeInfo(StringBuffer str) { String contentType[] = {"EMPTY", "SIMPLE", "ELEMENT", "MIXED"}; String derivedBy[] = {"EMPTY", "EXTENSION", "RESTRICTION"}; str.append("Complex type name='").append(fTargetNamespace).append(',').append(getTypeName()).append("', "); if (fBaseType != null) { str.append(" base type name='").append(fBaseType.getName()).append("', "); } str.append(" content type='").append(contentType[fContentType]).append("', "); str.append(" isAbstract='").append(getAbstract()).append("', "); str.append(" hasTypeId='").append(containsTypeID()).append("', "); str.append(" final='").append(fFinal).append("', "); str.append(" block='").append(fBlock).append("', "); if (fParticle != null) { str.append(" particle='").append(fParticle.toString()).append("', "); } str.append(" derivedBy='").append(derivedBy[fDerivedBy]).append("'. "); }
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()); }
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; }
public static boolean isSchemaTypesIdentical(XSTypeDefinition typeDefn1, XSTypeDefinition typeDefn2) { boolean typesIdentical = false; String type1Name = typeDefn1.getName(); String type2Name = typeDefn2.getName(); if (("anyType".equals(type1Name) && "anyType".equals(type2Name)) || ("anySimpleType".equals(type1Name) && "anySimpleType".equals(type2Name))) { typesIdentical = true; } if (!typesIdentical && isURIEqual(typeDefn1.getNamespace(), typeDefn2.getNamespace())) { // if targetNamespace of types are same, then check for equality of type names and of the base type if ((type1Name == null && type2Name == null) || (type1Name != null && type1Name.equals(type2Name)) && (isSchemaTypesIdentical(typeDefn1.getBaseType(), typeDefn2.getBaseType()))) { typesIdentical = true; } } return typesIdentical; } // isSchemaTypesIdentical
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 ); } }
public QName getElementType(String namespaceUri, String localName) { XSElementDeclaration element = this.model.getElementDeclaration( localName, namespaceUri); XSTypeDefinition type = element.getTypeDefinition(); String typeNamespaceUri = type.getNamespace(); String typeName = type.getName(); return new QName(typeNamespaceUri, typeName); }
public void printComplexTypesSummary( String namespace ) { XSNamedMap elementMap = schema.getComponentsByNamespace( XSConstants.TYPE_DEFINITION, namespace ); SortedSet<String> complexTypeNames = new TreeSet<String>(); for ( int i = 0; i < elementMap.getLength(); i++ ) { XSTypeDefinition typeDef = (XSTypeDefinition) elementMap.item( i ); if ( typeDef.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE ) { System.out.println( toString( ( (XSComplexTypeDefinition) typeDef ) ) ); complexTypeNames.add( typeDef.getName() ); } } System.out.println( complexTypeNames.size() + " complex types in namespace: '" + namespace + "':\n" ); for ( String typeName : complexTypeNames ) { System.out.println( typeName ); } }
/** * 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); } }
/** * register one global type */ public void addGlobalTypeDecl(XSTypeDefinition decl) { fGlobalTypeDecls.put(decl.getName(), decl); if (decl instanceof XSComplexTypeDecl) { ((XSComplexTypeDecl) decl).setNamespaceItem(this); } else if (decl instanceof XSSimpleTypeDecl) { ((XSSimpleTypeDecl) decl).setNamespaceItem(this); } }
private void init() { // build lookup map to avoid usage of XSModel#getElementDeclaration(...) -- sometimes returns null for element // declarations that definitely exist (observed for XPlanGML 4.0 schemas with ADE) XSNamedMap elDecls = xsModel.getComponents( XSConstants.ELEMENT_DECLARATION ); for ( int i = 0; i < elDecls.getLength(); i++ ) { XSElementDeclaration elDecl = (XSElementDeclaration) elDecls.item( i ); QName name = new QName( elDecl.getNamespace(), elDecl.getName() ); nameToElDecl.put( name, elDecl ); } XSNamedMap typeDefs = xsModel.getComponents( XSConstants.TYPE_DEFINITION ); for ( int i = 0; i < typeDefs.getLength(); i++ ) { XSTypeDefinition typeDef = (XSTypeDefinition) typeDefs.item( i ); QName name = new QName( typeDef.getNamespace(), typeDef.getName() ); nameToTypeDef.put( name, typeDef ); } }
/** * * @param element * @throws OdaException */ public ATreeNode( XSElementDecl element ) throws OdaException { this(); this.element = element; this.value = element.getName( ); this.type = ELEMENT_TYPE; if ( element.getTypeDefinition( ).getName( ) != null ) this.dataType = getDataType( element.getTypeDefinition( ).getName( ) ); else this.dataType = getDataType( element.getName( ) ); }
/** * Element/Attribute traversers call this method to check whether * the type is NOTATION without enumeration facet */ void checkNotationType(String refName, XSTypeDefinition typeDecl, Element elem) { if (typeDecl.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE && ((XSSimpleType)typeDecl).getVariety() == XSSimpleType.VARIETY_ATOMIC && ((XSSimpleType)typeDecl).getPrimitiveKind() == XSSimpleType.PRIMITIVE_NOTATION) { if ((((XSSimpleType)typeDecl).getDefinedFacets() & XSSimpleType.FACET_ENUMERATION) == 0) { reportSchemaError("enumeration-required-notation", new Object[]{typeDecl.getName(), refName, DOMUtil.getLocalName(elem)}, elem); } } }