getValue(ResultSet, int) is used for extraction and setValue(PreparedStatement, int, T) is used for population

The equals() and hashCode() methods on types work as expected.

The following features are supported:

• {@link com.puppetlabs.geppetto.pp.pptp.Type#getSuperType Super Type}

A Type may be used to represent a run-time type:

{@link Value}.type()

{@link Field#type()}
{@link Method#returnType()}
{@link Method#argumentTypes()}
{@link LocalVariable#type()}
{@link ArrayType#componentType()}

The following table illustrates which subinterfaces of Type are used to mirror types in the target VM --

The UNO type is not directly mapped to java.lang.Class for at least two reasons. For one, some UNO types (like UNSIGNED SHORT) do not have a matching Java class. For another, it can be necessary to describe a type which is unknown to the Java runtime system (for example, for delaying the need of a class, so that it is possible to generate it on the fly.)

A Type is uniquely determined by its type class (a TypeClass) and its type name (a String); these two will never be null. A Type may have an additional "z class" (a java.lang.Class), giving a Java class type that corresponds to the UNO type. Also, a Type can cache a type description (a com.sun.star.uno.ITypeDescription), which can be computed and set by TypeDescription.getTypeDescription.

 base types (tags: BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, BOOLEAN), type `void' (tag: VOID), the bottom type (tag: BOT), the missing type (tag: NONE). 

The behavior of the following types is defined in subclasses, which are all static inner classes of this class:

 class types (tag: CLASS, class: ClassType), array types (tag: ARRAY, class: ArrayType), method types (tag: METHOD, class: MethodType), package types (tag: PACKAGE, class: PackageType), type variables (tag: TYPEVAR, class: TypeVar), type arguments (tag: WILDCARD, class: WildcardType), polymorphic types (tag: FORALL, class: ForAll), the error type (tag: ERROR, class: ErrorType). 

This is NOT part of any supported API. If you write code that depends on this, you do so at your own risk. This code and its internal interfaces are subject to change or deletion without notice. @see TypeTags

Invariant: all x:entries | x.arity()>0

Note: except for "toString()" and "fold()", the return value of every method is always valid for all time; for example, given types A and B, and you call C=A.intersect(B), then the result C will always be the intersection of A and B even if the caller later constructs more sigs or subsigs or subsetsigs...

• Human presentable meta data such as name, version, description etc useful when assembling the system.
• the context object capabilities that this component requires
• the services that this component type is capable of providing
• the services that this component type requires to operate (and the names via which services are accessed)
• extended lifecycle stages that this component uses

UML

The following features are supported:

• {@link org.apache.tuscany.sdo.model.Type#getBaseType Base Type}
• {@link org.apache.tuscany.sdo.model.Type#getProperty Property}
• {@link org.apache.tuscany.sdo.model.Type#getAliasName Alias Name}
• {@link org.apache.tuscany.sdo.model.Type#getAny Any}
• {@link org.apache.tuscany.sdo.model.Type#isAbstract Abstract}
• {@link org.apache.tuscany.sdo.model.Type#isDataType Data Type}
• {@link org.apache.tuscany.sdo.model.Type#getName Name}
• {@link org.apache.tuscany.sdo.model.Type#isOpen Open}
• {@link org.apache.tuscany.sdo.model.Type#isSequenced Sequenced}
• {@link org.apache.tuscany.sdo.model.Type#getUri Uri}
• {@link org.apache.tuscany.sdo.model.Type#getAnyAttribute Any Attribute}

Type names are Java strings that look like Java class names. For example, the built-in annotation type is called uima.tcas.Annotation. The whole string is called the (fully) qualified type name. The part after the last period is called the short or base name. The rest of the name is the name space of the type. This part can be empty, in which case the qualified and the base name are identical.

Type system identifiers in general have the following syntax: they are non-empty strings whose first character is a letter (Unicode letter), followed by an arbitrary sequence of letters, digits and underscores. No other characters are legal parts of identifiers. A type name is then a non-empty sequence of identifiers separated by periods. See also Feature names.

 Type: PrimitiveType ArrayType SimpleType QualifiedType ParameterizedType WildcardType PrimitiveType: byte short char int long float double boolean void ArrayType: Type [ ] SimpleType: TypeName ParameterizedType: Type < Type { , Type } > QualifiedType: Type . SimpleName WildcardType: ? [ ( extends | super) Type ]  

 Type: AnnotatableType: PrimitiveType SimpleType QualifiedType NameQualifiedType WildcardType ArrayType ParameterizedType UnionType IntersectionType {@link PrimitiveType}: { Annotation } byte { Annotation } short { Annotation } char { Annotation } int { Annotation } long { Annotation } float { Annotation } double { Annotation } boolean { Annotation } void {@link ArrayType}: Type Dimension { Dimension } {@link SimpleType}: { Annotation } TypeName {@link QualifiedType}: Type . {Annotation} SimpleName {@link NameQualifiedType}: Name . { Annotation } SimpleName {@link WildcardType}: { Annotation } ? [ ( extends | super) Type ] {@link ParameterizedType}: Type < Type { , Type } > {@link UnionType}: Type | Type { | Type } {@link IntersectionType}: Type & Type { & Type } 

This is a convinience interface to help speed up the code, allowing for any type definition to handled in a consistent manner, independant of whether it's nested or not.

Application developers needing custom types can implement this interface (either directly or via subclassing an existing impl) or by the (slightly more stable, though more limited) {@link org.hibernate.usertype.UserType}interface.

Implementations of this interface must certainly be thread-safe. It is recommended that they be immutable as well, though that is difficult to achieve completely given the no-arg constructor requirement for custom types. @author Gavin King @author Steve Ebersole

@author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0

@author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0

All type objects are immutable. @author jhyde @since Feb 17, 2005 @version $Id: Type.java 315 2010-05-29 00:56:11Z jhyde $

The following features are supported:

• {@link org.pdtextensions.semanticanalysis.model.validators.Type#getLabel Label}
• {@link org.pdtextensions.semanticanalysis.model.validators.Type#getDescription Description}
• {@link org.pdtextensions.semanticanalysis.model.validators.Type#getDefaultSeverity Default Severity}
• {@link org.pdtextensions.semanticanalysis.model.validators.Type#getValidator Validator}
• {@link org.pdtextensions.semanticanalysis.model.validators.Type#getId Id}

This class represents primitive Java types (boolean, byte, char, double, float, int, long, and short) as well as object types (including arrays). It treats null and void (the "return value" of a void method) as null type, which is also considered as primitive.

Manipulation can also be done on those types by means of the given operations.

This class cannot be directed instantiated with "new". Users should use {@link #createType(String)} to create a type object with a name. If thename refers to a class, it must be a full name (including the package).

Objects of this class can also be associated with AST nodes during AST analysis. When the analyzer resolves the type of a node representing an expression or sub-expression in the Java program, it creates a type and associates it with that node with {@link #setType(ASTNode,Type)}. This information can be extracted with {@link #getType(ASTNode)}. @author Thomas Feng @version $Id: Type.java,v 1.8 2007/12/06 18:31:38 cxh Exp $ @since Ptolemy II 5.1 @Pt.ProposedRating Red (tfeng) @Pt.AcceptedRating Red (tfeng)

It encapsulates an Java type signature and it provides quick access to the components of the type. Note that all types are hashed into a hashtable (typeHash), that means that each distinct type is only allocated once, saving space and making equality checks cheap.

For simple types use the constants defined in this class. (Type.tInt, Type.tShort, ...). To create complex types use the static methods Type.tArray, Type.tMethod or Type.tClass. For classes, arrays and method types a sub class of class type is created which defines the extra type components. WARNING: The contents of this source file are not part of any supported API. Code that depends on them does so at its own risk: they are subject to change or removal without notice. @see ArrayType @see ClassType @see MethodType @author Arthur van Hoff

The class hierarchy for types distinguishes basic from wrapped types, with wrapped types providing additional information for basic types. For each basic type, this class provides isName() and toName() methods to replace instanceof tests and casts, respectively. For each wrapped type, this class additionally provides a hasName() method, which identifies instances of the wrapped type even if they are wrapped inside another (wrapped) type. In other words, invocations of hasName() are forwarded across wrapped types while invocations of isName() only apply to the outermost type object. For wrapped types, invocations of toName() are also forwarded across (other) wrapped types.

As an example, consider an int type wrapped in an annotated type and an alias type:

 Type i = NumberT.INT; Type j = new AnnotatedT(i); Type k = new AliasT("alias", j); 

 k.isAlias()        ⇒ true k.hasAlias()       ⇒ true k.toAlias()        ⇒ k k.isAnnotated()    ⇒ false k.hasAnnotated()   ⇒ true k.toAnnotated()    ⇒ j k.isInteger()      ⇒ false k.toInteger()      ⇒ error 

 Type r = k.resolve(); r.isAlias()        ⇒ false r.isAnnotated()    ⇒ false r.isInteger()      ⇒ true r.toInteger()      ⇒ i 

The {@link Tag} enumeration also identifies particular types.A type's tag can be accessed through {@link #tag()}, which is forwarded across wrapped types, and through {@link #wtag()}, which is not forwarded across wrapped types. As a result, tag() identifies basic types independent of whether they are wrapped or not, while wtag() always identifies the outermost type:

 k.tag()            ⇒ Tag.INTEGER k.wtag()           ⇒ Tag.ALIAS i.tag()            ⇒ Tag.INTEGER i.tag()            ⇒ Tag.INTEGER 

Each type can have one or more of the following annotations:

• Its source location represented as a {@link Location}.
• Its source language represented as a {@link Language} tag.
• Its scope represented as a {@link String}.
• Its constant value represented as a {@link Constant}.
• Its memory shape represented as a {@link Reference}. Only lvalues can have a shape.
• Its attributes represented as a list of {@link Attribute}values.