import ceylon.language { AnnotationType = Annotation } import ceylon.language.meta.model{ ClassOrInterface } "A `module` declaration from a `module.ceylon` compilation unit" shared sealed interface Module satisfies Identifiable & AnnotatedDeclaration { "The module version." shared formal String version; "The package members of the module." shared formal Package[] members; "The modules this module depends on." shared formal Import[] dependencies; "Finds a package by name. Returns `null` if not found." shared formal Package? findPackage(String name); "Finds a package by name in this module or in its dependencies. Note that all transitive `shared` dependencies are searched. Returns `null` if not found." shared formal Package? findImportedPackage(String name); "Searches for a resource by its path inside the module." since("1.1.0") shared formal Resource? resourceByPath(String path); "Find providers of the given [[service type|service]]. Returns all the service providers accessible to this module that: * are annotated with the [[service]] annotation, and * have the given class or interface as argument to the [[service]] annotation. The returned service providers will be returned in an unspecified and platform-dependent order. A provider usually does not provide the underlying functionality itself, but: * provides sufficient information to allow clients to decide which provider is best able to satisfy its needs, and * provides a means to access the underlying functionality (for example, by serving as a factory)." shared formal {Service*} findServiceProviders<Service>( "The service type." ClassOrInterface<Service> service); } "Model of an `import` declaration within a module declaration." shared sealed interface Import satisfies Identifiable & Annotated { "The name of the imported module." shared formal String name; "The compile-time version of the imported module." shared formal String version; "True if this imported module is shared." shared formal Boolean shared; "True if this imported module is optional." shared formal Boolean optional; "The containing module." shared formal Module container; } "Model of a `package` declaration from a `package.ceylon` compilation unit" shared sealed interface Package satisfies Identifiable & AnnotatedDeclaration { "The module this package belongs to." shared formal Module container; "True if this package is shared." shared formal Boolean shared; "Returns the list of member declarations that satisfy the given `Kind` type argument." shared formal Kind[] members<Kind>() 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" shared formal Kind[] annotatedMembers<Kind, Annotation>() given Kind satisfies NestableDeclaration given Annotation satisfies AnnotationType; "Looks up a member declaration by name, provided it satisfies the given `Kind` type argument. Returns `null` if no such member matches." shared formal Kind? getMember<Kind>(String name) given Kind satisfies NestableDeclaration; "The value with the given name. Returns `null` if not found." shared formal ValueDeclaration? getValue(String name); "The class or interface with the given name. Returns `null` if not found." shared formal ClassOrInterfaceDeclaration? getClassOrInterface(String name); "The function with the given name. Returns `null` if not found." shared formal FunctionDeclaration? getFunction(String name); "The type alias with the given name. Returns `null` if not found." shared formal AliasDeclaration? getAlias(String name); }