Context (GraniteDS API Documentation)

java.lang.Object
- org.granite.client.tide.Context

```
public class Context
extends Object
```
General Tide context implementation It can either wrap a Spring or CDI container or be used separately Currently only one context can be active at a time A context is created by a context manager

Author:

William DRAI

See Also:
ContextManager

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Context()`
	`Context(ContextManager contextManager, Context parentCtx, String contextId)` Create a context using the specified manager and context id Should not be used directly

Method Summary

Methods
Modifier and Type	Method and Description
`Map<String,Object>`	`allByAnnotatedWith(Class<? extends Annotation> annotationClass)` Return a map of all component instances annotated with the specified annotation
`<T> T[]`	`allByType(Class<T> type)` Return an array of all component instances implementing the expected type
`<T> T[]`	`allByType(Class<T> type, boolean create)` Return an array of all component instances implementing the expected type
`List<String>`	`allNames()` Return a list of all component names in this context
`<T> T`	`byName(String name)` Return a component instance by its name in the container InstanceStore implementations are free to (but don't have to) automatically create a suitable component instance with the expected name when no instance exists
`<T> T`	`byNameNoProxy(String name)` Return a component instance by its name in the container Does not create a default proxy (`ComponentImpl`) if no instance exists
`<T> T`	`byType(Class<T> type)` Return a component instance looked up by its type If more than one instance is found, throws a runtime exception
`void`	`callLater(Runnable runnable)` Convenience method to defer execution of a method in the main UI thread
`void`	`checkValid()` Check that this context is not finished
`void`	`clear()` Clear all data and instances in the context
`String`	`getContextId()` Context id
`ContextManager`	`getContextManager()` Managed for this context
`DataManager`	`getDataManager()` Data manager for this context
`EntityManager`	`getEntityManager()` Entity manager for this context
`EventBus`	`getEventBus()` Event bus for this context
`Map<String,Object>`	`getInitialBeans()` Map of beans defined before the initialization of the context so they can be registered in the DI container
`Context`	`getParentContext()` Parent context for conversation contexts
`void`	`initContext(Application application, EventBus eventBus, InstanceStore instanceStore)` Initialize the context
`void`	`initInstance(Object instance, String name)` Initialize an instance when it is added to the context
`boolean`	`isContextIdFromServer()` Indicate that the context id has been defined by the server Unused for now
`boolean`	`isFinished()` Indicate that the context is eligible for destruction
`void`	`markAsFinished()` Mark this context as eligible for destruction
`void`	`postInit()`
`void`	`remove(String name)` Remove the component instance having the specified name from the context May not work with all containers (Spring and CDI are static and cannot be modified after initialization)
`<T> T`	`set(String name, T instance)` Set a component instance as a managed instance with the specified name in the context May not work with all containers (Spring and CDI are static and cannot be modified after initialization)
`<T> T`	`set(T instance)` Set a component instance as a managed instance in the context May not work with all containers (Spring and CDI are static and cannot be modified after initialization)
`void`	`setContextId(String contextId, boolean fromServer)` Update the context id
`void`	`setDataManager(DataManager dataManager)` Set the data manager for this context

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Context
```
protected Context()
```
  - Context
```
public Context(ContextManager contextManager,
       Context parentCtx,
       String contextId)
```
    Create a context using the specified manager and context id Should not be used directly
    
    Parameters:
    contextManager - context manager
    parentCtx - parent context for conversation contexts (not supported yet)
    contextId - context id
- Method Detail
  - getContextManager
```
public ContextManager getContextManager()
```
    Managed for this context
    
    Returns:
    context manager
  - getEntityManager
```
public EntityManager getEntityManager()
```
    Entity manager for this context
    
    Returns:
    entity manager
  - setDataManager
```
public void setDataManager(DataManager dataManager)
```
    Set the data manager for this context
    
    Parameters:
    dataManager - data manager
    See Also:
    DataManager
  - getDataManager
```
public DataManager getDataManager()
```
    Data manager for this context
    
    Returns:
    data manager
  - getInitialBeans
```
public Map<String,Object> getInitialBeans()
```
    Map of beans defined before the initialization of the context so they can be registered in the DI container
    
    Returns:
    map of initialization beans keyed by name
  - initContext
```
public void initContext(Application application,
               EventBus eventBus,
               InstanceStore instanceStore)
```
    Initialize the context
    
    Parameters:
    application - application for this context (depends on the target platform/framework)
    eventBus - event bus for this context (depends on the framework and/or the DI container)
    instanceStore - instance store (depends on the DI container)
  - getEventBus
```
public EventBus getEventBus()
```
    Event bus for this context
    
    Returns:
    event bus
  - postInit
```
public void postInit()
```
  - getParentContext
```
public Context getParentContext()
```
    Parent context for conversation contexts
    
    Returns:
    parent context
  - getContextId
```
public String getContextId()
```
    Context id
    
    Returns:
    context id
  - isContextIdFromServer
```
public boolean isContextIdFromServer()
```
    Indicate that the context id has been defined by the server Unused for now
    
    Returns:
    true if id received from server
  - isFinished
```
public boolean isFinished()
```
    Indicate that the context is eligible for destruction
    
    Returns:
    true is finished
  - setContextId
```
public void setContextId(String contextId,
                boolean fromServer)
```
    Update the context id
    
    Parameters:
    contextId - context id
    fromServer - is this id received from the server ?
  - byName
```
public <T> T byName(String name)
```
    Return a component instance by its name in the container InstanceStore implementations are free to (but don't have to) automatically create a suitable component instance with the expected name when no instance exists
    
    Type Parameters:
    T - component type
    Parameters:
    name - component name
    
    Returns:
    component instance
  - byNameNoProxy
```
public <T> T byNameNoProxy(String name)
```
    Return a component instance by its name in the container Does not create a default proxy (ComponentImpl) if no instance exists
    
    Type Parameters:
    T - component type
    Parameters:
    name - component name
    
    Returns:
    component instance or null if not found
  - byType
```
public <T> T byType(Class<T> type)
```
    Return a component instance looked up by its type If more than one instance is found, throws a runtime exception
    
    Type Parameters:
    T - expected component type
    Parameters:
    type - expected component type
    
    Returns:
    component instance
  - allByType
```
public <T> T[] allByType(Class<T> type)
```
    Return an array of all component instances implementing the expected type
    
    Type Parameters:
    T - expected component type
    Parameters:
    type - expected component type
    
    Returns:
    array of component instances
  - allByType
```
public <T> T[] allByType(Class<T> type,
                boolean create)
```
    Return an array of all component instances implementing the expected type
    
    Type Parameters:
    T - expected component type
    Parameters:
    type - expected component type
    create - if true, should create an instance if none is existing
    
    Returns:
    array of component instances or null if no instance found
  - allByAnnotatedWith
```
public Map<String,Object> allByAnnotatedWith(Class<? extends Annotation> annotationClass)
```
    Return a map of all component instances annotated with the specified annotation
    
    Parameters:
    annotationClass - annotation
    
    Returns:
    map of component instances keyed by name
  - allNames
```
public List<String> allNames()
```
    Return a list of all component names in this context
    
    Returns:
    list of names
  - set
```
public <T> T set(String name,
        T instance)
```
    Set a component instance as a managed instance with the specified name in the context May not work with all containers (Spring and CDI are static and cannot be modified after initialization)
    
    Type Parameters:
    T - component type
    Parameters:
    name - component name
    instance - component instance
    
    Returns:
    component instance
  - set
```
public <T> T set(T instance)
```
    Set a component instance as a managed instance in the context May not work with all containers (Spring and CDI are static and cannot be modified after initialization)
    
    Type Parameters:
    T - component type
    Parameters:
    instance - component instance
    
    Returns:
    component instance
  - remove
```
public void remove(String name)
```
    Remove the component instance having the specified name from the context May not work with all containers (Spring and CDI are static and cannot be modified after initialization)
    
    Parameters:
    name - component name
  - clear
```
public void clear()
```
    Clear all data and instances in the context
  - initInstance
```
public void initInstance(Object instance,
                String name)
```
    Initialize an instance when it is added to the context
    
    Parameters:
    instance - component instance
    name - component name
  - checkValid
```
public void checkValid()
```
    Check that this context is not finished
    
    Throws:
    
    InvalidContextException - when context finished
  - callLater
```
public void callLater(Runnable runnable)
```
    Convenience method to defer execution of a method in the main UI thread
    
    Parameters:
    runnable - runnable method
  - markAsFinished
```
public void markAsFinished()
```
    Mark this context as eligible for destruction

Class Context

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Context

Context

Method Detail

getContextManager

getEntityManager

setDataManager

getDataManager

getInitialBeans

initContext

getEventBus

postInit

getParentContext

getContextId

isContextIdFromServer

isFinished

setContextId

byName

byNameNoProxy

byType

allByType

allByType

allByAnnotatedWith

allNames

set

set

remove

clear

initInstance

checkValid

callLater

markAsFinished