Class declaration.

Callable classes

Since Ceylon 1.2 classes are not always directly invokable (if the class has constructors, but not a default constructor). Thus members of ClassDeclaration which depend on the class parameter list typically have optional type, but are refined on ClassWithInitializerDeclaration to be non-optional. The exceptions to this are instantiate() and memberInstantiate(), which throw exceptions.

Usage sample for toplevel classes

Because some classes have type parameters, getting a model requires applying type arguments to the class declaration with classApply() in order to be able to instantiate that class. For example, here is how you would obtain a class model that you can instantiate from a toplevel class declaration:

class Foo<T>(){
    string => "Hello, our T is: ``typeLiteral<T>()``";
}

void test(){
    // We need to apply the Integer closed type to the Foo declaration in order to get the Foo<Integer> closed type
    Class<Foo<Integer>,[]> classModel = `class Foo`.classApply<Foo<Integer>,[]>(`Integer`);
    // This will print: Hello, our T is: ceylon.language::Integer
    print(classModel());
}

Usage sample for member classes

For member classes it is a bit longer, because member classes need to be applied not only their type arguments but also the containing type, so you should use memberClassApply() and start by giving the containing closed type:

class Outer(){
    shared class Inner(){
        string => "Hello";
    }
}

void test(){
    // apply the containing closed type `Outer` to the member class declaration `Outer.Inner`
    MemberClass<Outer,Outer.Inner,[]> memberClassModel = `class Outer.Inner`.memberClassApply<Outer,Outer.Inner,[]>(`Outer`);
    // We now have a MemberClass, which needs to be applied to a containing instance in order to become an
    // invokable class model:
    Class<Outer.Inner,[]> boundMemberClassModel = memberClassModel(Outer());
    // This will print: Hello
    print(boundMemberClassModel());
}

no type hierarchy

Attributes
abstractSource Codeshared formal Boolean abstract

True if the class has an abstract annotation.

annotationSource Codeshared formal Boolean annotation

True if the current declaration is an annotation class or function.

Since 1.2.0
anonymousSource Codeshared formal Boolean anonymous

True if the class is an anonymous class, as is the case for the class of object value declarations.

defaultConstructorSource Codeshared formal CallableConstructorDeclaration? defaultConstructor

A constructor declaration representing the class initializer (for a class with a parameter list) or the default constructor, or null if the class lacks both a parameter list and a default constructor.

Since 1.2.0
finalSource Codeshared formal Boolean final

True if the class has a final annotation.

objectValueSource Codeshared formal ValueDeclaration? objectValue

This anonymous class' object value declaration if this class is an anonymous class. null otherwise.

Since 1.1.0
parameterDeclarationsSource Codeshared formal FunctionOrValueDeclaration[]? parameterDeclarations

The list of parameter declarations for this class. Returns null if the class lacks both a parameter list and a default constructor.

Since 1.2.0
serializableSource Codeshared formal Boolean serializable

True if the class is serializable class.

Since 1.2.0
Inherited Attributes
Attributes inherited from: Object
Attributes inherited from: ClassOrInterfaceDeclaration
Attributes inherited from: Declaration
Attributes inherited from: GenericDeclaration
Attributes inherited from: NestableDeclaration
Attributes inherited from: TypedDeclaration
Methods
annotatedConstructorDeclarationsSource Codeshared formal ConstructorDeclaration[] annotatedConstructorDeclarations<Annotation>()
given Annotation satisfies AnnotationType

Returns the list of constructors declared on this class that are annotated with the given Annotation type argument. This includes unshared constructors.

Since 1.2.0
classApplySource Codeshared formal Class<Type,Arguments> classApply<Type = Anything, Arguments = Nothing>(AppliedType<Anything>[] typeArguments)

Applies the given closed type arguments to this toplevel class declaration in order to obtain a class model. See this code sample for an example on how to use this.

Throws
  • IncompatibleTypeException

    If the specified Type or Arguments type arguments are not compatible with the actual result.

  • TypeApplicationException

    If the specified closed type argument values are not compatible with the actual result's type parameters.

constructorDeclarationsSource Codeshared formal ConstructorDeclaration[] constructorDeclarations()

Returns the list of constructors declared on this class. This includes unshared constructors.

Since 1.2.0
getConstructorDeclarationSource Codeshared formal <CallableConstructorDeclaration|ValueConstructorDeclaration>? getConstructorDeclaration(String name)

Looks up a constructor declaration directly declared on this class, by name. Returns null if no such constructor matches. This includes unshared constructors but not inherited constructors (since constructors are not members).

Since 1.2.0
getParameterDeclarationSource Codeshared formal FunctionOrValueDeclaration? getParameterDeclaration(String name)

Gets a parameter declaration by name. Returns null if this class lacks both a parameter list and a default constructor, or if no such parameter exists in the parameter list.

Since 1.2.0
instantiateSource Codeshared default Object instantiate(AppliedType<Anything>[] typeArguments = [], Anything[] arguments)

Creates a new instance of this toplevel class, by applying the specified type arguments and value arguments.

Parameters:
  • typeArguments = []
Throws
  • IncompatibleTypeException

    If the specified type or value arguments are not compatible with this toplevel class, or if the class lacks both a parameter list and a default constructor.

memberClassApplySource Codeshared formal MemberClass<Container,Type,Arguments> memberClassApply<Container = Nothing, Type = Anything, Arguments = Nothing>(AppliedType<Object> containerType, AppliedType<Anything>[] typeArguments)

Applies the given closed container type and type arguments to this member class declaration in order to obtain a member class model. See this code sample for an example on how to use this.

Throws
  • IncompatibleTypeException

    If the specified Container, Type or Arguments type arguments are not compatible with the actual result.

  • TypeApplicationException

    If the specified closed container type or type argument values are not compatible with the actual result's container type or type parameters.

memberInstantiateSource Codeshared default Object memberInstantiate(Object container, AppliedType<Anything>[] typeArguments = [], Anything[] arguments)

Creates a new instance of this member class, by applying the specified type arguments and value arguments.

Parameters:
  • typeArguments = []
Throws
  • IncompatibleTypeException

    If the specified container, type or value arguments are not compatible with this method, or if the class lacks both a parameter list and a default constructor.

Inherited Methods
Methods inherited from: Object
Methods inherited from: Annotated
Methods inherited from: AnnotatedDeclaration
Methods inherited from: ClassOrInterfaceDeclaration
Methods inherited from: GenericDeclaration