Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Alpha5
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.modeshape.jcr
Class ExecutionContext

    java.lang.Object
      org.modeshape.jcr.ExecutionContext

All Implemented Interfaces:
  Cloneable, ClassLoaderFactory, ThreadPoolFactory

Direct Known Subclasses:
  TextExtractorContext

    @Immutable
    public class ExecutionContext

extends Object
implements ClassLoaderFactory, ThreadPoolFactory, Cloneable

An ExecutionContext is a representation of the environment or context in which a component or operation is operating. Some components require this context to be passed into individual methods, allowing the context to vary with each method invocation. Other components require the context to be provided before it's used, and will use that context for all its operations (until it is given a different one).

ExecutionContext instances are `immutable`, so components may hold onto references to them without concern of those contexts changing. Contexts may be used to create other contexts that vary the environment and/or security context. For example, an ExecutionContext could be used to create another context that references the same `namespace registry` but which has a different `security context`.

Field Summary
`static ExecutionContext` | `DEFAULT_CONTEXT`

Constructor Summary
`` | `ExecutionContext()` Create an instance of an execution context that uses the `current JAAS calling context` , with default implementations for all other components (including default namespaces in the `namespace registry`.
`` | `ExecutionContext(ExecutionContext original)` Create a copy of the supplied execution context.
`protected` | `ExecutionContext(ExecutionContext original, SecurityContext securityContext)` Create a copy of the supplied execution context, but use the supplied `AccessControlContext` instead.
`protected` | `ExecutionContext(SecurityContext securityContext, NamespaceRegistry namespaceRegistry, ValueFactories valueFactories, PropertyFactory propertyFactory, MimeTypeDetector mimeTypeDetector, ClassLoaderFactory classLoaderFactory, ThreadPoolFactory threadPoolFactory, BinaryStore binaryStore, Map<String,String> data, String processId)` Create an instance of the execution context by supplying all parameters.

Method Summary
`ExecutionContext` | `clone()`
`BinaryStore` | `getBinaryStore()` Get the binary store that should be used to store binary values.
`ClassLoader` | `getClassLoader(String... classpath)` Get a class loader for the supplied classpath.
`protected ClassLoaderFactory` | `getClassLoaderFactory()` Get the class loader factory used by this context.
`Map<String,String>` | `getData()` Get the immutable map of custom data that is affiliated with this context.
`String` | `getId()` Get the unique identifier for this context.
`Logger` | `getLogger(Class<?> clazz)` Return a logger associated with this context.
`Logger` | `getLogger(String name)` Return a logger associated with this context.
`MimeTypeDetector` | `getMimeTypeDetector()` Return an object that can be used to determine the MIME type of some content, such as the content of a file.
`NamespaceRegistry` | `getNamespaceRegistry()` Get the (mutable) namespace registry for this context.
`String` | `getProcessId()` Get the identifier for the process in which this context exists.
`PropertyFactory` | `getPropertyFactory()` Get the factory for creating `Property` objects.
`SecurityContext` | `getSecurityContext()` Get the `security context` for this context.
`Executor` | `getThreadPool(String name)` Obtain a thread pool with the supplied name, or create and return one if no thread pool exists with that name.
`protected ThreadPoolFactory` | `getThreadPoolFactory()`
`ValueFactories` | `getValueFactories()` Get the factories that should be used to create values for `properties`.
`protected void` | `initializeDefaultNamespaces(NamespaceRegistry namespaceRegistry)` Method that initializes the default namespaces for namespace registries.
`void` | `releaseThreadPool(Executor pool)` Signal that the supplied thread pool is no longer needed.
`String` | `toString()`
`ExecutionContext` | `with(BinaryStore binaryStore)` Create a new execution context that mirrors this context but that uses the supplied binary store.
`ExecutionContext` | `with(ClassLoaderFactory classLoaderFactory)` Create a new execution context that mirrors this context but that uses the supplied `class loader factory`.
`ExecutionContext` | `with(Map<String,String> data)` Create a new execution context that mirrors this context but that contains the supplied data.
`ExecutionContext` | `with(MimeTypeDetector mimeTypeDetector)` Create a new execution context that is the same as this context, but which uses the supplied `MIME type detector`.
`ExecutionContext` | `with(NamespaceRegistry namespaceRegistry)` Create a new execution context that mirrors this context but that uses the supplied namespace registry.
`ExecutionContext` | `with(PropertyFactory propertyFactory)` Create a new execution context that mirrors this context but that uses the supplied `factory`.
`ExecutionContext` | `with(SecurityContext securityContext)` Create an `ExecutionContext` that is the same as this context, but which uses the supplied `security context`.
`ExecutionContext` | `with(String processId)` Create a new execution context that mirrors this context but that contains the supplied process identifier.
`ExecutionContext` | `with(String key, String value)` Create a new execution context that mirrors this context but that contains the supplied key-value pair in the new context's data.
`ExecutionContext` | `with(ThreadPoolFactory threadPoolFactory)` Create a new execution context that mirrors this context but that uses the supplied `thread pool factory`.

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

Field Detail

### DEFAULT_CONTEXT

    public static final ExecutionContext DEFAULT_CONTEXT

Constructor Detail

### ExecutionContext

    public ExecutionContext()

  Create an instance of an execution context that uses the `current JAAS calling context` , with default implementations for all other components (including default namespaces in the `namespace registry`.

### ExecutionContext

    public ExecutionContext(ExecutionContext original)

  Create a copy of the supplied execution context.

  Parameters:
    `original` - the original
  Throws:
    `IllegalArgumentException` - if the original is null

### ExecutionContext

    protected ExecutionContext(ExecutionContext original,
                               SecurityContext securityContext)

  Create a copy of the supplied execution context, but use the supplied `AccessControlContext` instead.

  Parameters:
    `original` - the original
    `securityContext` - the security context
  Throws:
    `IllegalArgumentException` - if the original or access control context are is null

### ExecutionContext

    protected ExecutionContext(SecurityContext securityContext,
                               NamespaceRegistry namespaceRegistry,
                               ValueFactories valueFactories,
                               PropertyFactory propertyFactory,
                               MimeTypeDetector mimeTypeDetector,
                               ClassLoaderFactory classLoaderFactory,
                               ThreadPoolFactory threadPoolFactory,
                               BinaryStore binaryStore,
                               Map<String,String> data,
                               String processId)

  Create an instance of the execution context by supplying all parameters.

  Parameters:
    `securityContext` - the security context, or null if there is no associated authenticated user
    `namespaceRegistry` - the namespace registry implementation, or null if a thread-safe version of `SimpleNamespaceRegistry` instance should be used
    `valueFactories` - the `ValueFactories` implementation, or null if a `StandardValueFactories` instance should be used
    `propertyFactory` - the `PropertyFactory` implementation, or null if a `BasicPropertyFactory` instance should be used
    `mimeTypeDetector` - the `MimeTypeDetector` implementation, or null if the context should use a `MimeTypeDetectors` instance with an `ExtensionBasedMimeTypeDetector`
    `classLoaderFactory` - the `ClassLoaderFactory` implementation, or null if a `StandardClassLoaderFactory` instance should be used
    `threadPoolFactory` - the `ThreadPoolFactory` implementation, or null if a `ThreadPools` instance should be used
    `binaryStore` - the `BinaryStore` implementation, or null if a default `TransientBinaryStore` should be used
    `data` - the custom data for this context, or null if there is no such data
    `processId` - the unique identifier of the process in which this context exists, or null if it should be generated

Method Detail

### getClassLoaderFactory

    protected ClassLoaderFactory getClassLoaderFactory()

  Get the class loader factory used by this context.

  Returns:
    the class loader factory implementation; never null

### getThreadPoolFactory

    protected ThreadPoolFactory getThreadPoolFactory()

### getLogger

    public Logger getLogger(Class<?> clazz)

  Return a logger associated with this context. This logger records only those activities within the context and provide a way to capture the context-specific activities. All log messages are also sent to the system logger, so classes that log via this mechanism should not also `obtain a system logger`.

  Parameters:
    `clazz` - the class that is doing the logging
  Returns:
    the logger, named after `clazz`; never null
  See Also:
    `getLogger(String)`

### getLogger

    public Logger getLogger(String name)

  Return a logger associated with this context. This logger records only those activities within the context and provide a way to capture the context-specific activities. All log messages are also sent to the system logger, so classes that log via this mechanism should not also `obtain a system logger`.

  Parameters:
    `name` - the name for the logger
  Returns:
    the logger, named after `clazz`; never null
  See Also:
    `getLogger(Class)`

### getMimeTypeDetector

    public MimeTypeDetector getMimeTypeDetector()

  Return an object that can be used to determine the MIME type of some content, such as the content of a file.

  Returns:
    the detector; never null

### getSecurityContext

    public SecurityContext getSecurityContext()

  Get the `security context` for this context.

  Returns:
    the security context; never `null`

### getNamespaceRegistry

    public NamespaceRegistry getNamespaceRegistry()

  Get the (mutable) namespace registry for this context.

  Returns:
    the namespace registry; never `null`

### getPropertyFactory

    public final PropertyFactory getPropertyFactory()

  Get the factory for creating `Property` objects.

  Returns:
    the property factory; never `null`

### getValueFactories

    public ValueFactories getValueFactories()

  Get the factories that should be used to create values for `properties`.

  Returns:
    the property value factory; never null

### getBinaryStore

    public BinaryStore getBinaryStore()

  Get the binary store that should be used to store binary values. This store is used by the `BinaryFactory` in the `getValueFactories()`.

  Returns:
    the binary store; never null

### getClassLoader

    public ClassLoader getClassLoader(String... classpath)

  Description copied from interface: `ClassLoaderFactory`
  Get a class loader for the supplied classpath.

  Specified by:
    `getClassLoader` in interface `ClassLoaderFactory`
  Parameters:
    `classpath` - the classpath to use
  Returns:
    the class loader; may not be null

### getThreadPool

    public Executor getThreadPool(String name)

  Description copied from interface: `ThreadPoolFactory`
  Obtain a thread pool with the supplied name, or create and return one if no thread pool exists with that name. When finished with the thread pool, it should be `released`.

  Specified by:
    `getThreadPool` in interface `ThreadPoolFactory`
  Parameters:
    `name` - the name of the thread pool; may not be null
  Returns:
    the thread pool executor; never null

### releaseThreadPool

    public void releaseThreadPool(Executor pool)

  Description copied from interface: `ThreadPoolFactory`
  Signal that the supplied thread pool is no longer needed.

  Specified by:
    `releaseThreadPool` in interface `ThreadPoolFactory`
  Parameters:
    `pool` - the pool that is no longer needed

### getId

    public String getId()

  Get the unique identifier for this context. Each context will always have a unique identifier.

  Returns:
    the unique identifier string; never null and never empty

### getProcessId

    public String getProcessId()

  Get the identifier for the process in which this context exists. Multiple contexts running in the same "process" will all have the same identifier.

  Returns:
    the identifier for the process; never null and never empty

### getData

    public Map<String,String> getData()

  Get the immutable map of custom data that is affiliated with this context.

  Returns:
    the custom data; never null but possibly empty

### with

    public ExecutionContext with(BinaryStore binaryStore)

  Create a new execution context that mirrors this context but that uses the supplied binary store.

  Parameters:
    `binaryStore` - the binary store that should be used, or null if the default implementation should be used
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied binary store; never null

### with

    public ExecutionContext with(NamespaceRegistry namespaceRegistry)

  Create a new execution context that mirrors this context but that uses the supplied namespace registry. The resulting context's `value factories` and `property factory` all make use of the new namespace registry.

  Parameters:
    `namespaceRegistry` - the new namespace registry implementation, or null if the default implementation should be used
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied registry; never null

### with

    public ExecutionContext with(MimeTypeDetector mimeTypeDetector)

  Create a new execution context that is the same as this context, but which uses the supplied `MIME type detector`.

  Parameters:
    `mimeTypeDetector` - the new MIME type detector implementation, or null if the context should use a `MimeTypeDetectors` instance with an `ExtensionBasedMimeTypeDetector`
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied detector implementation; never null

### with

    public ExecutionContext with(ClassLoaderFactory classLoaderFactory)

  Create a new execution context that mirrors this context but that uses the supplied `class loader factory`.

  Parameters:
    `classLoaderFactory` - the new class loader factory implementation, or null if the default implementation should be used
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied class loader factory implementation; never null

### with

    public ExecutionContext with(ThreadPoolFactory threadPoolFactory)

  Create a new execution context that mirrors this context but that uses the supplied `thread pool factory`.

  Parameters:
    `threadPoolFactory` - the new thread pool factory implementation, or null if the default implementation should be used
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied thread pool factory implementation; never null

### with

    public ExecutionContext with(PropertyFactory propertyFactory)

  Create a new execution context that mirrors this context but that uses the supplied `factory`.

  Parameters:
    `propertyFactory` - the new propertyfactory implementation, or null if the default implementation should be used
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied property factory implementation; never null

### with

    public ExecutionContext with(SecurityContext securityContext)

  Create an `ExecutionContext` that is the same as this context, but which uses the supplied `security context`.

  Parameters:
    `securityContext` - the new security context to use; may be null
  Returns:
    the execution context that is identical with this execution context, but with a different security context; never null
  Throws:
    `IllegalArgumentException` - if the `name` is null

### with

    public ExecutionContext with(Map<String,String> data)

  Create a new execution context that mirrors this context but that contains the supplied data. Note that the supplied map is always copied to ensure that it is immutable.

  Parameters:
    `data` - the data that is to be affiliated with the resulting context or null if the resulting context should have no data
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied data; never null
  Since:
    2.0

### with

    public ExecutionContext with(String key,
                                 String value)

  Create a new execution context that mirrors this context but that contains the supplied key-value pair in the new context's data.

  Parameters:
    `key` - the key for the new data that is to be affiliated with the resulting context
    `value` - the data value to be affiliated with the supplied key in the resulting context, or null if an existing data affiliated with the key should be removed in the resulting context
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied data; never null
  Since:
    2.0

### with

    public ExecutionContext with(String processId)

  Create a new execution context that mirrors this context but that contains the supplied process identifier.

  Parameters:
    `processId` - the identifier of the process
  Returns:
    the execution context that is identical with this execution context, but which uses the supplied process identifier; never null
  Since:
    2.1

### clone

    public ExecutionContext clone()

  Overrides:
    `clone` in class `Object`
  See Also:
    `Object.clone()`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`
  See Also:
    `Object.toString()`

### initializeDefaultNamespaces

    protected void initializeDefaultNamespaces(NamespaceRegistry namespaceRegistry)

  Method that initializes the default namespaces for namespace registries.

  Parameters:
    `namespaceRegistry` - the namespace registry

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Alpha5
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2008-2012 JBoss, a division of Red Hat. All Rights Reserved.