Component (Vertigo Core 0.7.0-beta2 API)

All Known Implementing Classes:

DefaultComponent
```
public interface Component
```
The component is the primary unit of processing in Vertigo. Vertigo networks consist of any number of components that are arbitrarily connected to one another and communicate with one another using message passing through internally-defined input and output ports.
Components receive messages on input ports and send messages on output ports, but component-to-component relationships are defined externally to the component implementation in the NetworkConfig. This means that when a message is sent to an output port, the component doesn't know where the message will go. Instead, Vertigo handles message routing internally, abstracting relationship details from component implementations.
Each component may define any number of input and output ports. Ports are created lazily by simply referencing them in InputCollector and OutputCollector interfaces. If a message is sent to a port that has no connections then the message will simply disappear.

Author:

Jordan Halterman

Method Summary

Methods
Modifier and Type	Method and Description
`Cluster`	`cluster()` Returns the cluster to which the component belongs.
`org.vertx.java.platform.Container`	`container()` Gets the component container instance.
`InstanceContext`	`context()` Returns the component instance context.
`InputCollector`	`input()` Returns the component's `InputCollector`.
`org.vertx.java.core.logging.Logger`	`logger()` Returns the instance logger.
`OutputCollector`	`output()` Returns the component's `OutputCollector`.
`Component`	`start()` Starts the component.
`Component`	`start(org.vertx.java.core.Handler<org.vertx.java.core.AsyncResult<Component>> doneHandler)` Starts the component.
`org.vertx.java.core.Vertx`	`vertx()` Gets the component Vertx instance.

- Method Detail
  - vertx
```
org.vertx.java.core.Vertx vertx()
```
    Gets the component Vertx instance.
    
    Returns:
    The component Vertx instance.
  - container
```
org.vertx.java.platform.Container container()
```
    Gets the component container instance.
    
    Returns:
    The component container instance.
  - input
```
InputCollector input()
```
    Returns the component's InputCollector. This is the element of the component which provides an interface for receiving messages from other components.
    
    Returns:
    The components InputCollector.
  - output
```
OutputCollector output()
```
    Returns the component's OutputCollector. This is the element of the component which provides an interface for sending messages to other components.
    
    Returns:
    The component's OutputCollector.
  - context
```
InstanceContext context()
```
    Returns the component instance context. The instance context can be used to retrieve useful information about an entire network.
    
    Returns:
    The instance context.
  - cluster
```
Cluster cluster()
```
    Returns the cluster to which the component belongs.
    The cluster type is dependent upon the method by which the component's network was deployed. If the network was deployed in local-mode then the cluster will be locally supported. If the network was deployed in cluster-mode then the cluster will be backed by fault-tolerant data structures.
    
    Returns:
    The cluster to which the component belongs.
  - logger
```
org.vertx.java.core.logging.Logger logger()
```
    Returns the instance logger. This is a special logger that references the Vertigo component instance and can allow for fine grained control of logging within Vertigo components.
    
    Returns:
    The logger for the component instance.
  - start
```
Component start()
```
    Starts the component. When the component is started, the component will use a ComponentCoordinator to retrieve its context from the current cluster context. This means that input and output connections are not set up until the component has been started.
    
    Returns:
    The component instance.
  - start
```
Component start(org.vertx.java.core.Handler<org.vertx.java.core.AsyncResult<Component>> doneHandler)
```
    Starts the component.
    When the component is started, the component will use a ComponentCoordinator to retrieve its context from the current cluster context. This means that input and output connections are not set up until the component has been started.
    
    Parameters:
    doneHandler - An asynchronous handler to be called once the component is started.
    
    Returns:
    The component instance.

Interface Component

Method Summary

Method Detail

vertx

container

input

output

context

cluster

logger

start

start