import ceylon.language.meta.model { 
    Value, 
    Attribute, 
    AppliedType = Type, 
    IncompatibleTypeException, 
    StorageException 
}
​
"""A value declaration.
   
   <a name="toplevel-sample">a>
   ### Usage sample for toplevel value​
   
   Getting a model requires applying type arguments to the​
   value declaration with [[apply]] in order to be able to read that value. For example, here is how you would​
   obtain a value model that you can read from a toplevel attribute declaration:
   
       String foo = "Hello";
       
       void test(){
           // We need to apply the the foo declaration in order to get the foo value model​
           Value<String> valueModel = `value foo`.apply<String>();
           // This will print: Hello​
           print(valueModel.get());
       }
   
   <a name="member-sample">a>
   ### Usage sample for attributes​
	
   For attributes it is a bit longer, because attributes need to be applied the containing type, so you should 
   use [[memberApply]] and start by giving the containing closed type:
   
       class Outer(){
           shared String foo => "Hello";
       }
	
       void test(){
           // Apply the containing closed type `Outer` to the attribute declaration `Outer.foo`​
           Attribute<Outer,String> valueModel = `value Outer.foo`.memberApply<Outer,String>(`Outer`);
           // We now have an Attribute, which needs to be applied to a containing instance in order to become a​
           // readable value:​
           Value<String> boundValueModel = valueModel(Outer());
           // This will print: Hello​
           print(boundValueModel.get());
       }
   """
​shared sealed interface ValueDeclaration​
        satisfies FunctionOrValueDeclaration & GettableDeclaration {
    
    "True if this declaration is annotated with [[late|ceylon.language::late]]."​
    since("1.2.0")
    shared formal Boolean late;
    
    "True if this declaration is annotated with [[variable|ceylon.language::variable]]."​
    shared formal Boolean variable;
​
    "True if this declaration is an `object` declaration, whose type is an anonymous class."​
    since("1.1.0")
    shared formal Boolean objectValue;
    
    "This value's anonymous class declaration if this value is an object declaration. `null` otherwise."​
    since("1.1.0")
    shared formal ClassDeclaration? objectClass;
​
    "Applies this value declaration in order to obtain a value model. 
     See [this code sample](#toplevel-sample) for an example on how to use this."​
    throws(`class IncompatibleTypeException`, "If the specified `Get` or `Set` type arguments are not compatible with the actual result.")
    shared formal Value<Get, Set> apply<Get=Anything, Set=Nothing>();
    
    "Applies this `static` value declaration in order to obtain a value model."​
    throws(`class IncompatibleTypeException`, "If the specified `Get` or `Set` type arguments are not compatible with the actual result.")
    shared formal Value<Get, Set> staticApply<Get=Anything, Set=Nothing>(AppliedType<Object> containerType);
​
    "Applies the given closed container type to this attribute declaration in order to obtain an attribute model. 
     See [this code sample](#member-sample) for an example on how to use this."​
    throws(`class IncompatibleTypeException`, "If the specified `Container`, `Get` or `Set` type arguments are not compatible with the actual result.")
    shared formal Attribute<Container, Get, Set> memberApply<Container=Nothing, Get=Anything, Set=Nothing>(AppliedType<Object> containerType);
    
    "Reads the current value of this toplevel value."​
    shared actual default Anything get()
            => apply<Anything, Nothing>().get();
    
    "Reads the current value of this attribute on the given container instance."​
    throws(`class IncompatibleTypeException`, "If the specified container is not compatible with this attribute.")
    throws(`class StorageException`,
           "If this attribute is not stored at runtime, for example if it is neither shared nor captured.")
    shared actual default Anything memberGet(Object container)
            => memberApply<Nothing, Anything, Nothing>(`Nothing`).bind(container).get();
​
    "Reads the current value of this `static` attribute."​
    throws(`class IncompatibleTypeException`, "If the specified `Get` or `Set` type arguments are not compatible with the actual result.")
    shared actual default Anything staticGet(AppliedType<Object> containerType)
            => staticApply<Anything, Nothing>(containerType).get();
​
    "Sets the current value of this toplevel value."​
    shared default void set(Anything newValue)
        => apply<Anything,Nothing>().setIfAssignable(newValue);
​
    "Sets the current value of this attribute on the given container instance."​
    throws(`class IncompatibleTypeException`, "If the specified container or new value type is not compatible with this attribute.")
    throws(`class StorageException`,
           "If this attribute is not stored at runtime, for example if it is neither shared nor captured.")
    shared formal void memberSet(Object container, Anything newValue);
    //=> memberApply<Nothing, Anything, Nothing>(`Nothing`).bind(container).setIfAssignable(newValue);​
​
    "Returns the setter declaration for this variable if there is one, `null` otherwise."​
    shared formal SetterDeclaration? setter;
​
}
​