Beginning in DDMS 4.0.1, a ddms:type element can contain child text. The intent of this text is to provide further context when the ddms:type element references an IC activity.
{@table.footer}{@table.header Nested Elements}None. {@table.footer}{@table.header Attributes}{@child.info ddms:qualifier|0..1|11111}{@child.info ddms:value|0..1|11111}{@child.info ism:<securityAttributes>|0..*|01111}{@table.footer}{@table.header Validation Rules}{@ddms.rule The qualified name of this element must be correct.|Error|11111}{@ddms.rule ddms:qualifier must exist if ddms:value is set.|Error|11111}{@ddms.rule The child text must not be used before the DDMS version in which it was introduced.|Error|11111}{@ddms.rule Security attributes must not be used before the DDMS version in which they were introduced.|Error|11111}{@ddms.rule A ddms:qualifier can be set with no ddms:value.|Warning|11111}{@ddms.rule This component can be used with no values set.|Warning|11111}{@table.footer} @author Brian Uri! @since 0.9.b
getValue(ResultSet, int) is used for extraction and setValue(PreparedStatement, int, T) is used for population
@author tiwe @param < T>The equals() and hashCode() methods on types work as expected.
The following features are supported:
?"), or a primitive data type (like char).
@since 1.2
@author Kaiyang Liu (original)
@author Robert Field (rewrite)
@author Scott Seligman (generics)
A Type may be used to represent a run-time type:
{@link Value}.type()or a compile-time 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 --
| Subinterfaces of {@link PrimitiveType} | ||
|---|---|---|
| Type declared in target as | Is mirrored as an instance of | |
boolean | {@link BooleanType} | |
byte | {@link ByteType} | |
char | {@link CharType} | |
double | {@link DoubleType} | |
float | {@link FloatType} | |
int | {@link IntegerType} | |
long | {@link LongType} | |
short | {@link ShortType} | |
void | {@link VoidType} | |
| Subinterfaces of {@link ReferenceType} | ||
| Type declared in target as | For example | Is mirrored as an instance of |
| a class | Date | {@link ClassType} |
| an interface | Runnable | {@link InterfaceType} |
| an array | {@link ArrayType} | |
| an array | int[] | {@link ArrayType} whose{@link ArrayType#componentType() componentType()} is{@link IntegerType} |
| an array | Date[] | {@link ArrayType} whose{@link ArrayType#componentType() componentType()} is{@link ClassType} |
| an array | Runnable[] | {@link ArrayType} whose{@link ArrayType#componentType() componentType()} is{@link InterfaceType} |
TYPE. 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...
UML
The following features are supported:
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 ]
@since 2.0
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 }
@since 2.0
java.sql.Types
@version $Revision: 1.1 $ $Date: 2004/11/26 01:51:16 $
@author Tim Anderson
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.
@see SimpleType @see ComplexType @author dzwiers www.refractions.net @source $URL$@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
Allows for a unified handling of declared and primitive types and usage within templates. Instances are obtained through {@link TypeFactory}. @author Gunnar Morling
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:
{ "id":"4eb3f3f1e679eb839b4c594b", "type":"organization" }
@author joel
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
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); Then the following method invocations have the following results: k.isAlias() ⇒ true k.hasAlias() ⇒ true k.toAlias() ⇒ k k.isAnnotated() ⇒ false k.hasAnnotated() ⇒ true k.toAnnotated() ⇒ j k.isInteger() ⇒ false k.toInteger() ⇒ errorThe {@link #resolve()} method can be used to strip any wrappedtypes:
Type r = k.resolve(); r.isAlias() ⇒ false r.isAnnotated() ⇒ false r.isInteger() ⇒ true r.toInteger() ⇒ iThe {@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.INTEGEREach type can have one or more of the following annotations:
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |