The following features are supported:
new Button(panel.getContainer());
This interface defines methods for accessing RDF container resources. These methods operate on the RDF statements contained in a model. The container implementation may cache state from the underlying model, so objects should not be added to or removed from the container by directly manipulating its properties, whilst the container is being accessed through this interface.
When a member is deleted from a container using this interface, or an iterator returned through this interface, all the other members with higher ordinals are renumbered using an algorithm which may depend on the type of the container.
This interface provides methods supporting typed literals. This means that methods are provided which will translate a built in type, or an object to an RDF Literal. This translation is done by invoking the toString()
method of the object, or its built in equivalent. The reverse translation is also supported. This is built in for built in types. Factory objects, provided by the application, are used for application objects.
This interface provides methods for supporting enhanced resources. An enhanced resource is a resource to which the application has added behaviour. RDF containers are examples of enhanced resources built in to this package. Enhanced resources are supported by encapsulating a resource created by an implementation in another class which adds the extra behaviour. Factory objects are used to construct such enhanced resources.
To create and inject an instance of {@code Foo}:
Container c = ...; Foo foo = c.inject(Foo.class);@see ContainerBuilder @author crazybob@google.com (Bob Lee)
There is one instance of the Container for each EJB type (deployment desc). When a JAR is deployed on the EJB server, a Container instance is created for each EJB declared in the ejb-jar.xml for the EJB JAR.
The Container interface provides methods called from other parts of the RI as well as from generated EJBHome/EJBObject implementations.
Often technologies that are built on top of JAX-WS (such as Tango) needs to negotiate private contracts between them and the container. This interface allows such technologies to query the negotiated SPI by using the {@link #getSPI(Class)}.
For example, if a security pipe needs to get some information from a container, they can do the following:
This protects JAX-WS from worrying about the details of such contracts, while still providing the necessary service of hooking up those parties.
Technologies that run inside JAX-WS server runtime can access this object through {@link WSEndpoint#getContainer()}. In the client runtime, it can be accessed from {@link ContainerResolver#getContainer()} @author Kohsuke Kawaguchi @see WSEndpoint
Often technologies that are built on top of JAX-WS (such as Tango) needs to negotiate private contracts between them and the container. This interface allows such technologies to query the negotiated SPI by using the {@link #getSPI(Class)}.
For example, if a security pipe needs to get some information from a container, they can do the following:
This protects JAX-WS from worrying about the details of such contracts, while still providing the necessary service of hooking up those parties.
Technologies that run inside JAX-WS server runtime can access this object through {@link WSEndpoint#getContainer()}. In the client runtime, it can be accessed from {@link ContainerResolver#getContainer()} @author Kohsuke Kawaguchi @see WSEndpoint
A specialized set of identified Items. Basically the Container is a set of {@link Item}s, but it imposes certain constraints on its contents. These constraints state the following:
The Container can be visualized as a representation of a relational database table. Each Item in the Container represents a row in the table, and all cells in a column (identified by a Property ID) have the same data type. Note that as with the cells in a database table, no Property in a Container may be empty, though they may contain null
values.
Note that though uniquely identified, the Items in a Container are not necessarily {@link Container.Ordered ordered} or {@link Container.Indexed indexed}.
Containers can derive Item ID's from the item properties or use other, container specific or user specified identifiers.
If a container is {@link Filterable filtered} or {@link Sortable sorted}, most of the the methods of the container interface and its subinterfaces (container size, {@link #containsId(Object)}, iteration and indices etc.) relate to the filtered and sorted view, not to the full container contents. See individual method javadoc for exceptions to this (adding and removing items).
The Container interface is split to several subinterfaces so that a class can implement only the ones it needs.
@author Vaadin Ltd @since 3.0The following features are supported:
A container object provides a execution environment for mobile agent. It is responsible for managing the execution of agents, starting and stopping them and has to provide internal message passing and resource management.
To manage agents a Container
uses an instance of a class implementing AgentInfo
by which an agent can be identified and all resources can be mapped to it; the container functions as a factory for the AgentInfo
object.
Codehaus.org. @author Ben Yu
<containers>
element of the <cactus>
task.
@version $Id: Container.java 239130 2005-01-29 15:49:18Z vmassol $
Container
represents an allocated resource in the cluster.
The ResourceManager
is the sole authority to allocate any Container
to applications. The allocated Container
is always on a single node and has a unique {@link ContainerId}. It has a specific amount of {@link Resource} allocated.
It includes details such as:
Typically, an ApplicationMaster
receives the Container
from the ResourceManager
during resource-negotiation and then talks to the NodManager
to start/stop containers.
Containers will exist at several conceptual levels within Tomcat. The following examples represent common cases:
A Container may also be associated with a number of support components that provide functionality which might be shared (by attaching it to a parent Container) or individually customized. The following support components are currently recognized:
log()
method signatures of the ServletContext
interface. ServletContext
interface, enabling custom linkages to existing server components when Tomcat is embedded in a larger server. Implementations of this interface need to be appropriately synchronized -- the implementations of the hashbelt rely on this object to be threadsafe. @author Gregory Block @author Ralf Joachim @version $Revision: 7950 $ $Date: 2006-04-25 16:09:10 -0600 (Tue, 25 Apr 2006) $ @since 1.0
The following features are supported:
See {@link ContainerLoader} for how to push graph and attributes data in the container and see{@link ContainerUnloader} for how to retrieve data in the container. @author Mathieu Bastian @see Importer @see Processor
The EJBDeployer creates instances of subclasses of this class and calls the appropriate initialization methods.
A Container does not perform any significant work, but instead delegates to the plugins to provide for all kinds of algorithmic functionality. @see EJBDeployer @author Rickard Oberg @author Marc Fleury @author Scott Stark. @author Bill Burke @author David Jencks @author Christoph G. Jung @author Dimitris Andreadis @author adrian@jboss.org @author anil.saldhana@jboss.org @version $Revision: 98925 $ @jmx.mbean extends="org.jboss.system.ServiceMBean"
When OFBiz starts, the main thread will create the Container
instance and then call the container's init
method. If the method returns without throwing an exception the container will be added to a list of initialized containers. After all instances have been created and initialized, the main thread will call the start
method of each container in the list. When OFBiz shuts down, a separate shutdown thread will call the stop
method of each container. Implementations should anticipate asynchronous calls to the methods by different threads.
Containers might be loaded more than once (have more than one instance).
Container
object is used to process HTTP requests and compose HTTP responses. The Request
objects that are handed to this container contain all information relating to the received message. The responsibility of the container is to interpret the request and compose a suitable response. All implementations must ensure that the container is thread safe as it will receive multiple HTTP transactions concurrently. Also it should be known that the Response
object used to deliver the HTTP response will only commit and send once it has its OutputStream
closed.
The Container
is entirely responsible for the HTTP message headers and body. It is up to the implementation to ensure that it complies to RFC 2616 or any previous specification. All headers and the status line can be modified by this object.
@author Niall Gallagher
NOTES:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|