Satisfied Interfaces: Annotated, AnnotatedDeclaration, ClassOrInterfaceDeclaration, Declaration, FunctionalDeclaration, GenericDeclaration, NestableDeclaration, TypedDeclaration

Class declaration.

### 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());
    }

Attributes
abstract | Source Code shared formal Boolean abstract True if the class has an abstract annotation.
anonymous | Source Code shared formal Boolean anonymous True if the class is an object class.
final | Source Code shared formal Boolean final True if the class has a final annotation.

Inherited Attributes
Attributes inherited from: Object hash, string
Attributes inherited from: ClassOrInterfaceDeclaration caseTypes, extendedType, isAlias, satisfiedTypes
Attributes inherited from: Declaration name, qualifiedName
Attributes inherited from: FunctionalDeclaration annotation, parameterDeclarations
Attributes inherited from: GenericDeclaration typeParameterDeclarations
Attributes inherited from: NestableDeclaration actual, container, containingModule, containingPackage, default, formal, shared, toplevel
Attributes inherited from: TypedDeclaration openType

Methods
classApply | Source Code shared formal Class<Type,Arguments> classApply<Type = Anything, Arguments = Nothing>(Type<Anything>[] typeArguments) given Arguments satisfies Anything[] 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.
instantiate | Source Code shared default Anything instantiate(Type<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.
memberClassApply | Source Code shared formal MemberClass<Container,Type,Arguments> memberClassApply<Container = Nothing, Type = Anything, Arguments = Nothing>(Type<Container> containerType, Type<Anything>[] typeArguments) given Arguments satisfies Anything[] 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.
memberInstantiate | Source Code shared default Anything memberInstantiate(Object container, Type<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.

Inherited Methods
Methods inherited from: Object equals
Methods inherited from: AnnotatedDeclaration annotations
Methods inherited from: ClassOrInterfaceDeclaration annotatedDeclaredMemberDeclarations, annotatedMemberDeclarations, apply, declaredMemberDeclarations, getDeclaredMemberDeclaration, getMemberDeclaration, memberApply, memberDeclarations
Methods inherited from: FunctionalDeclaration getParameterDeclaration
Methods inherited from: GenericDeclaration getTypeParameterDeclaration