Examples of SchemaType

client.net.sf.saxon.ce.type.SchemaType
SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.
There is a hierarchy of interfaces that extend SchemaType, representing the top levels of the schema type system: SimpleType and ComplexType, with SimpleType further subdivided into List, Union, and Atomic types.

The implementations of these interfaces are organized into a different hierarchy: on the one side, built-in types such as AnyType, AnySimpleType, and the built-in atomic types and list types; on the other side, user-defined types defined in a schema.
dk.brics.xact.analysis.flowgraph.SchemaType
Schema type.
net.sf.saxon.type.SchemaType
SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.
There is a hierarchy of interfaces that extend SchemaType, representing the top levels of the schema type system: SimpleType and ComplexType, with SimpleType further subdivided into List, Union, and Atomic types.

The implementations of these interfaces are organized into a different hierarchy: on the one side, built-in types such as AnyType, AnySimpleType, and the built-in atomic types and list types; on the other side, user-defined types defined in a schema.
org.apache.pig.EvalFunc.SchemaType
org.apache.syncope.common.types.SchemaType
org.apache.syncope.types.SchemaType
org.apache.torque.engine.database.model.SchemaType
Enum for types used in Torque schema.xml files. @author org.apache.torque.templates.typemapping.SchemaType
org.apache.vxquery.types.SchemaType
org.apache.xmlbeans.SchemaType
Represents a schema type.
SchemaType is the metadata "type" class for {@link XmlObject}, and it plays the analogous role for {@link XmlObject} that {@link java.lang.Class} plays for{@link java.lang.Object}.
Every XML Bean class corresponds to a singleton SchemaType object obtainable by ClassName.type (e.g., {@link XmlNonPositiveInteger#type}), and every XML Bean instance has an actual SchemaType, obtainable by {@link XmlObject#schemaType}. The ClassName.type and schemaType() mechanisms are analogous to the ordinary Java ClassName.class and obj.getClass() mechanisms.
All schema types are represented by a SchemaType, this includes all types regardless of whether they are built-in or user-defined, compiled or uncompiled, simple or complex.
In addition, a compiled XML Bean type system includes special "document" schema types each representing a document containing nothing but a single element for each global element, and special "attribute" schema types each representing a fragment containing nothing but a single global attribute for global attribute.
Do not confuse Schema Types with other types of Schema Components such as {@link SchemaGlobalElement Global Elements}, {@link SchemaGlobalAttribute Global Attributes}, {@link SchemaModelGroup Named Model Groups}, or {@link SchemaAttributeGroup Attribute Groups}. SchemaType represents a Type component, not any of the other kinds of components. There are different kinds of metadata objects for the different Schema components.
The space of SchemaTypes is divided as follows:
- First, there is the universal base type and the universal subtype. These are {@link XmlObject#type}(corresponding to xs:anyType) and {@link XmlBeans#NO_TYPE}, respectively. The first type is a base type of all other types. The other type indicates the absence of type information and, at least in set-theoretic terms, is a subtype of all other types.
- There is another universal base type that is the base type for all simple types. This is the {@link XmlAnySimpleType#type}, corresponding to xs:anySimpleType. Only XmlObject.type and XmlAnySimpleType.type return true for {@link #isURType}, and only XmlBeans.NO_TYPE returns true for {@link #isNoType}.
- The two "special" kinds of types that are generated that do not formally exist in the actual Schema specification are document types and global attribute types (corresponding to documents that contain a global element, or fragments that contain a global attribute). They can be detected using {@link #isDocumentType} and {@link #isAttributeType}. Other than their anonymity (lack of a type name) and their appearance only at the root of an instance, they are otherwise just like ordinary complex types.
- Simple types can be detected using {@link #isSimpleType}. Complex types are consdered to be all the types that are not simple.
- Simple types are divided into three varieties: atomic types, list types, and union types. Which variety of simple type you have can be discoverd using {@link #getSimpleVariety}. It will return either {@link #ATOMIC}, {@link #LIST}, or {@link #UNION}.
- An {@link #ATOMIC} simple type is always based on one of the20 built-in primitive schema types. You can determine the underlying primitive type for an atomic simple type by calling {@link #getPrimitiveType}. An atomic type may add facet restrictions on top of the primitive type, and these facets can be explored using {@link #getFacet}, {@link #getWhiteSpaceRule}, {@link #matchPatternFacet}, {@link #getEnumerationValues}, and related methods.
- A {@link #LIST} simple type is always based on another non-listsimple type. The underlying list item type can be obtained by using {@link #getListItemType}.
- A {@link #UNION} simple type is always composed out of a number ofother simple types. The direct members of the union can be obtained by {@link #getUnionMemberTypes}. When unions consist of other unions, it is useful to know useful to know the "leaves of the union tree", so the set of non-union types making up the union can be obtained by {@link #getUnionConstituentTypes}. The closure of the entire "union tree" is {@link #getUnionSubTypes} (this includesthe type itself). For simple unions that do not consist of other unions, all three of these sets are the same.
- Complex types have nested structure. They are divided into four content types: empty content, simple content, element-only content, and mixed content. All kinds of complex types may have attributes. The content type for a complex type can be dermined using {@link #getContentType}. This will return {@link #EMPTY_CONTENT}, {@link #SIMPLE_CONTENT}, {@link #ELEMENT_CONTENT}, or {@link #MIXED_CONTENT}.
- If a complex type has {@link #EMPTY_CONTENT}, the content model will be null.
- If a complex type has {@link #SIMPLE_CONTENT}, then it will extend the simple type that describes the content. In addition, the type may impose additional simple type facet restrictions; these can be determined in the same way they are for a simple type.
- If a complex type has {@link #ELEMENT_CONTENT} or {@link #MIXED_CONTENT}, then the detailed content model can be determined by examining the particle tree (which may be null for MIXED_CONTENT). The particle tree can be obtained via {@link #getContentModel}.
- When working with a complex type, most users will find it sufficient to discover the summarized shape of the content model and attribute model using {@link #getElementProperties}, {@link #getAttributeProperties}, and related methods rather than examining the particle tree and attribute model directly.
@see SchemaTypeLoader @see XmlObject#schemaType @see SimpleValue#instanceType
org.codehaus.xfire.wsdl.SchemaType
An XSD type. @author Dan Diephouse
org.geotools.gce.imagemosaic.catalog.index.SchemaType
3.org/2001/XMLSchema}anyType"> <sequence> <element name="attributes" type="{http://www.w3.org/2001/XMLSchema}string"/> </sequence> <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}string" /> <attribute name="ref" type="{http://www.w3.org/2001/XMLSchema}string" /> </restriction> </complexContent> </complexType>
org.pdf4j.saxon.type.SchemaType
SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.
There is a hierarchy of interfaces that extend SchemaType, representing the top levels of the schema type system: SimpleType and ComplexType, with SimpleType further subdivided into List, Union, and Atomic types.

The implementations of these interfaces are organized into a different hierarchy: on the one side, built-in types such as AnyType, AnySimpleType, and the built-in atomic types and list types; on the other side, user-defined types defined in a schema.

Examples of org.pdf4j.saxon.type.SchemaType

                    }
                    if (ann2 == -1) {
                        // defensive programming
                        ann2 = StandardNames.XS_UNTYPED;
                    }
                    final SchemaType type1 = config.getSchemaType(ann1);
                    final SchemaType type2 = config.getSchemaType(ann2);
                    final boolean isSimple1 = type1.isSimpleType() || ((ComplexType)type1).isSimpleContent();
                    final boolean isSimple2 = type2.isSimpleType() || ((ComplexType)type2).isSimpleContent();
                    if (isSimple1 != isSimple2) {
                        explain(config, "one element has a simple type, the other does not", flags);
                        return false;
                    }
                    if (isSimple1 && isSimple2) {

View Full Code Here

0 1 2 3 4 5 6

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.