import ceylon.language { AnnotationType = Annotation }
import ceylon.language.meta.model {
Class,
MemberClass,
AppliedType = Type,
IncompatibleTypeException,
TypeApplicationException
}
"""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.
<a name="toplevel-sample"></a>
### 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());
}
<a name="member-sample"></a>
### 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());
}
"""
shared sealed interface ClassDeclaration
of ClassWithInitializerDeclaration | ClassWithConstructorsDeclaration
satisfies ClassOrInterfaceDeclaration {
"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")
shared formal CallableConstructorDeclaration? defaultConstructor;
"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")
shared formal FunctionOrValueDeclaration[]? parameterDeclarations;
"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")
shared formal FunctionOrValueDeclaration? getParameterDeclaration(String name);
"True if the current declaration is an annotation class or function."
since("1.2.0")
shared formal Boolean annotation;
"True if the class has an [[abstract|ceylon.language::abstract]] annotation."
shared formal Boolean abstract;
"True if the class is serializable class."
since("1.2.0")
shared formal Boolean serializable;
"True if the class is an anonymous class, as is the case for the class of object value declarations."
shared formal Boolean anonymous;
"This anonymous class' object value declaration if this class is an anonymous class. `null` otherwise."
since("1.1.0")
shared formal ValueDeclaration? objectValue;
"True if the class has a [[final|ceylon.language::final]] annotation."
shared formal Boolean final;
"Applies the given closed type arguments to this toplevel class declaration in order to obtain a class model.
See [this code sample](#toplevel-sample) for an example on how to use this."
throws(`class IncompatibleTypeException`,
"If the specified `Type` or `Arguments` type arguments are not
compatible with the actual result.")
throws(`class TypeApplicationException`,
"If the specified closed type argument values are not compatible
with the actual result's type parameters.")
shared formal Class<Type, Arguments> classApply
<Type=Anything, Arguments=Nothing>
(AppliedType<>* typeArguments)
given Arguments satisfies Anything[];
"Applies the given closed type arguments to this `static` member class declaration
in order to obtain a class model."
throws(`class IncompatibleTypeException`,
"If the specified `Type` or `Arguments` type arguments are not
compatible with the actual result.")
throws(`class TypeApplicationException`,
"If the specified closed type argument values are not compatible
with the actual result's type parameters.")
shared formal Class<Type, Arguments> staticClassApply<Type=Anything, Arguments=Nothing>
(AppliedType<Object> containerType, AppliedType<>* 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](#member-sample) for an example on how to use this."
throws(`class IncompatibleTypeException`,
"If the specified `Container`, `Type` or `Arguments` type arguments
are not compatible with the actual result.")
throws(`class TypeApplicationException`,
"If the specified closed container type or type argument values
are not compatible with the actual result's container type or
type parameters.")
shared formal MemberClass<Container, Type, Arguments> memberClassApply
<Container=Nothing, Type=Anything, Arguments=Nothing>
(AppliedType<Object> containerType, AppliedType<>* typeArguments)
given Arguments satisfies Anything[];
"Creates a new instance of this toplevel class,
by applying the specified type arguments and value arguments."
throws(`class 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.")
shared default Object instantiate(AppliedType<>[] typeArguments = [], Anything* arguments)
=> classApply<Object, Nothing>(*typeArguments).apply(*arguments);
"Creates a new instance of this `static` member class,
by applying the specified type arguments and value arguments."
shared default Object staticInstantiate(AppliedType<Object> containerType, AppliedType<>[] typeArguments = [], Anything* arguments)
=> staticClassApply<Object, Nothing>(containerType, *typeArguments).apply(*arguments);
"Creates a new instance of this member class, by applying the specified
type arguments and value arguments."
throws(`class 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.")
shared default Object memberInstantiate
(Object container, AppliedType<>[] typeArguments = [], Anything* arguments)
=> memberClassApply<Nothing, Object, Nothing>(`Nothing`, *typeArguments).bind(container).apply(*arguments);
"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")
shared formal <CallableConstructorDeclaration|ValueConstructorDeclaration>? getConstructorDeclaration(String name);
"Returns the list of constructors declared on this class. This includes unshared constructors."
since("1.2.0")
shared formal ConstructorDeclaration[] constructorDeclarations();
"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")
shared formal ConstructorDeclaration[] annotatedConstructorDeclarations<Annotation>()
given Annotation satisfies AnnotationType;
}