Satisfied Interfaces: Annotated, AnnotatedDeclaration, Declaration, GenericDeclaration, NestableDeclaration, TypedDeclaration
Direct Known Satisfying Interfaces: ClassDeclaration, InterfaceDeclaration
All Known Subtypes Hierarchy

- ClassOrInterfaceDeclaration
  - ClassDeclaration
  - InterfaceDeclaration

A class or interface declaration.

### Usage sample for toplevel classes

Because some classes have type parameters, getting a model requires applying type arguments to the class declaration with apply in order to be able to instantiate that class. For example, here is how you would obtain a class or interface 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
        ClassOrInterface<Foo<Integer>> classOrInterfaceModel = `class Foo`.apply<Foo<Integer>>(`Integer`);
        assert(is Class<Foo<Integer>,[]> classOrInterfaceModel);
        // This will print: Hello, our T is: ceylon.language::Integer
        print(classOrInterfaceModel());
    }

Note that there are more specialised versions of apply in ClassDeclaration.classApply and InterfaceDeclaration.interfaceApply.

### Usage sample for member classes

For member classes or interfaces it is a bit longer, because member types need to be applied not only their type arguments but also the containing type, so you should use memberApply 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`
        value memberClassModel = `class Outer.Inner`.memberApply<Outer,Outer.Inner>(`Outer`);
        assert(is MemberClass<Outer,Outer.Inner,[]> memberClassModel);
        // 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());
    }

Note that there are more specialised versions of memberApply in ClassDeclaration.memberClassApply and InterfaceDeclaration.memberInterfaceApply.

Attributes
caseTypes | Source Code shared formal OpenType[] caseTypes If this type has an `of` clause, this is the list of case types for the current type.
extendedType | Source Code shared formal OpenClassType? extendedType This type's extended type, unless this is the class for Anything, which is the root of the type hierarchy and thus does not have any extended type.
isAlias | Source Code shared formal Boolean isAlias True if this type is an alias type, in which case the extendedType will contain the substituted type.
satisfiedTypes | Source Code shared formal OpenInterfaceType[] satisfiedTypes The list of types satisfied by this type.

Inherited Attributes
Attributes inherited from: Object hash, string
Attributes inherited from: Declaration name, qualifiedName
Attributes inherited from: GenericDeclaration typeParameterDeclarations
Attributes inherited from: NestableDeclaration actual, container, containingModule, containingPackage, default, formal, shared, toplevel
Attributes inherited from: TypedDeclaration openType

Methods
annotatedDeclaredMemberDeclarations | Source Code shared formal Kind[] annotatedDeclaredMemberDeclarations<Kind, Annotation>() given Kind satisfies NestableDeclaration Returns the list of member declarations that satisfy the given `Kind` type argument and that are annotated with the given `Annotation` type argument
annotatedMemberDeclarations | Source Code shared formal Kind[] annotatedMemberDeclarations<Kind, Annotation>() given Kind satisfies NestableDeclaration Returns the list of member declarations that satisfy the given `Kind` type argument and that are annotated with the given `Annotation` type argument
apply | Source Code shared formal ClassOrInterface<Type> apply<Type = Anything>(Type<Anything>[] typeArguments) Applies the given closed type arguments to this toplevel class or interface declaration in order to obtain a class or interface model. See this code sample for an example on how to use this. Throws: IncompatibleTypeException If the specified `Type` type argument is not compatible with the actual result. TypeApplicationException If the specified closed type argument values are not compatible with the actual result's type parameters.
declaredMemberDeclarations | Source Code shared formal Kind[] declaredMemberDeclarations<Kind>() given Kind satisfies NestableDeclaration Returns the list of member declarations that satisfy the given `Kind` type argument.
getDeclaredMemberDeclaration | Source Code shared formal Kind? getDeclaredMemberDeclaration<Kind>(String name) given Kind satisfies NestableDeclaration Looks up a member declaration by name, provided it satisfies the given `Kind` type argument. Returns `null` if no such member matches.
getMemberDeclaration | Source Code shared formal Kind? getMemberDeclaration<Kind>(String name) given Kind satisfies NestableDeclaration Looks up a member declaration by name, provided it satisfies the given `Kind` type argument. Returns `null` if no such member matches.
memberApply | Source Code shared formal Member<Container,ClassOrInterface<Type>>&ClassOrInterface<Type> memberApply<Container = Nothing, Type = Anything>(Type<Container> containerType, Type<Anything>[] typeArguments) Applies the given closed container type and type arguments to this member class or interface declaration in order to obtain a member class or interface model. See this code sample for an example on how to use this. Throws: IncompatibleTypeException If the specified `Container` or `Type` 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.
memberDeclarations | Source Code shared formal Kind[] memberDeclarations<Kind>() given Kind satisfies NestableDeclaration Returns the list of member declarations that satisfy the given `Kind` type argument.

Inherited Methods
Methods inherited from: Object equals
Methods inherited from: AnnotatedDeclaration annotations
Methods inherited from: GenericDeclaration getTypeParameterDeclaration