| Package | Description | 
|---|---|
| groovyx.gpars.activeobject | |
| groovyx.gpars.actor | 
 
    This package holds classes forming the public actor API. 
 | 
| groovyx.gpars.actor.impl | 
 
    This package holds classes some non-public aspects of actor implementation. 
 | 
| groovyx.gpars.agent | |
| groovyx.gpars.dataflow | 
 
    This package holds classes for basic dataflow concurrency constructs, like dataflow variables, streams and threads. 
 | 
| groovyx.gpars.dataflow.expression | |
| groovyx.gpars.dataflow.impl | |
| groovyx.gpars.dataflow.operator | 
 
    This package holds classes representing operators and channels necessary for full dataflow concurrency. 
 | 
| groovyx.gpars.dataflow.stream | |
| groovyx.gpars.group | 
| Modifier and Type | Field and Description | 
|---|---|
private java.util.Map<java.lang.String,PGroup> | 
ActiveObjectRegistry.registry  | 
| Modifier and Type | Method and Description | 
|---|---|
PGroup | 
ActiveObjectRegistry.findGroupById(java.lang.String groupId)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ActiveObjectRegistry.register(java.lang.String groupId,
        PGroup group)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected PGroup | 
Actor.parallelGroup
The parallel group to which the message stream belongs 
 | 
| Modifier and Type | Method and Description | 
|---|---|
PGroup | 
Actor.getParallelGroup()
Retrieves the group to which the actor belongs 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractLoopingActor.setParallelGroup(PGroup group)  | 
void | 
Actor.setParallelGroup(PGroup group)
Sets the parallel group. 
 | 
| Constructor and Description | 
|---|
Actor(DataflowExpression<java.lang.Object> joinLatch,
     PGroup parallelGroup)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SequentialProcessingActor.setParallelGroup(PGroup group)
Sets the actor's group. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AgentCore.setPGroup(PGroup pGroup)
Sets an actor group to use for task scheduling 
 | 
| Modifier and Type | Field and Description | 
|---|---|
static PGroup | 
Dataflow.DATA_FLOW_GROUP
The parallel group used by all Dataflow Concurrency actors by default. 
 | 
private PGroup | 
LazyDataflowVariable.group  | 
private PGroup | 
DataCallback.parallelGroup  | 
| Modifier and Type | Field and Description | 
|---|---|
static java.lang.ThreadLocal<PGroup> | 
Dataflow.activeParallelGroup
Maps threads/tasks to parallel groups they belong to 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static PGroup | 
Dataflow.retrieveCurrentDFPGroup()
Retrieves the thread-local value of the active PGroup or the default DataflowGroup 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
DataflowQueue.binaryChoice(PGroup group,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)  | 
void | 
DataflowReadChannel.binaryChoice(PGroup group,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)
Directs the output to one of the two output channels depending on the boolean result of the provided closure. 
 | 
void | 
DataflowQueue.binaryChoice(PGroup group,
            java.util.Map<java.lang.String,java.lang.Object> params,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)  | 
void | 
DataflowReadChannel.binaryChoice(PGroup group,
            java.util.Map<java.lang.String,java.lang.Object> params,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)
Directs the output to one of the two output channels depending on the boolean result of the provided closure. 
 | 
<V> DataflowReadChannel<V> | 
DataflowQueue.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowReadChannel.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)
Creates and attaches a new operator processing values from the channel 
 | 
<V> DataflowReadChannel<V> | 
SyncDataflowQueue.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
SyncDataflowStreamReadAdapter.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
SyncDataflowVariable.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowQueue.chainWith(PGroup group,
         java.util.Map<java.lang.String,java.lang.Object> params,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowReadChannel.chainWith(PGroup group,
         java.util.Map<java.lang.String,java.lang.Object> params,
         groovy.lang.Closure<V> closure)
Creates and attaches a new operator processing values from the channel 
 | 
void | 
DataflowQueue.choice(PGroup group,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)  | 
void | 
DataflowReadChannel.choice(PGroup group,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)
Directs the output to one of the output channels depending on the int result of the provided closure. 
 | 
void | 
DataflowQueue.choice(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)  | 
void | 
DataflowReadChannel.choice(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)
Directs the output to one of the output channels depending on the int result of the provided closure. 
 | 
DataflowReadChannel<T> | 
DataflowQueue.filter(PGroup group,
      groovy.lang.Closure<java.lang.Boolean> closure)  | 
DataflowReadChannel<T> | 
DataflowReadChannel.filter(PGroup group,
      groovy.lang.Closure<java.lang.Boolean> closure)
Creates and attaches a new operator that will filter data using the provided closure 
 | 
DataflowReadChannel<T> | 
DataflowQueue.filter(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      groovy.lang.Closure<java.lang.Boolean> closure)  | 
DataflowReadChannel<T> | 
DataflowReadChannel.filter(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      groovy.lang.Closure<java.lang.Boolean> closure)
Creates and attaches a new operator that will filter data using the provided closure 
 | 
void | 
DataflowQueue.into(PGroup group,
    DataflowWriteChannel<T> target)  | 
void | 
DataflowReadChannel.into(PGroup group,
    DataflowWriteChannel<T> target)
Makes the output of the current channel to be an input for the specified channel 
 | 
void | 
DataflowQueue.into(PGroup group,
    java.util.Map<java.lang.String,java.lang.Object> params,
    DataflowWriteChannel<T> target)  | 
void | 
DataflowReadChannel.into(PGroup group,
    java.util.Map<java.lang.String,java.lang.Object> params,
    DataflowWriteChannel<T> target)
Makes the output of the current channel to be an input for the specified channel 
 | 
<V> DataflowReadChannel<V> | 
DataflowQueue.merge(PGroup group,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowReadChannel.merge(PGroup group,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)
Merges channels together as inputs for a single dataflow operator. 
 | 
<V> DataflowReadChannel<V> | 
DataflowQueue.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowReadChannel.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)
Merges channels together as inputs for a single dataflow operator. 
 | 
<V> DataflowReadChannel<V> | 
SyncDataflowQueue.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
SyncDataflowStreamReadAdapter.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
SyncDataflowVariable.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowQueue.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowReadChannel.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)
Merges channels together as inputs for a single dataflow operator. 
 | 
<V> DataflowReadChannel<V> | 
DataflowQueue.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowReadChannel.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)
Merges channels together as inputs for a single dataflow operator. 
 | 
void | 
DataflowQueue.separate(PGroup group,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)  | 
void | 
DataflowReadChannel.separate(PGroup group,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)
Allows the closure to output different values to different output channels. 
 | 
void | 
DataflowQueue.separate(PGroup group,
        java.util.Map<java.lang.String,java.lang.Object> params,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)  | 
void | 
DataflowReadChannel.separate(PGroup group,
        java.util.Map<java.lang.String,java.lang.Object> params,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)
Allows the closure to output different values to different output channels. 
 | 
void | 
DataflowQueue.split(PGroup group,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)  | 
void | 
DataflowReadChannel.split(PGroup group,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)
Splits the output of the current channel to be an input for the specified channels 
 | 
void | 
DataflowQueue.split(PGroup group,
     java.util.List<DataflowWriteChannel<T>> targets)  | 
void | 
DataflowReadChannel.split(PGroup group,
     java.util.List<DataflowWriteChannel<T>> targets)
Makes the output of the current channel to be an input for the specified channels 
 | 
void | 
DataflowQueue.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)  | 
void | 
DataflowReadChannel.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)
Splits the output of the current channel to be an input for the specified channels 
 | 
void | 
DataflowQueue.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowWriteChannel<T>> targets)  | 
void | 
DataflowReadChannel.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowWriteChannel<T>> targets)
Makes the output of the current channel to be an input for the specified channels 
 | 
DataflowReadChannel<T> | 
DataflowQueue.tap(PGroup group,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
DataflowReadChannel.tap(PGroup group,
   DataflowWriteChannel<T> target)
Taps into the pipeline. 
 | 
DataflowReadChannel<T> | 
SyncDataflowQueue.tap(PGroup group,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
SyncDataflowStreamReadAdapter.tap(PGroup group,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
SyncDataflowVariable.tap(PGroup group,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
DataflowQueue.tap(PGroup group,
   java.util.Map<java.lang.String,java.lang.Object> params,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
DataflowReadChannel.tap(PGroup group,
   java.util.Map<java.lang.String,java.lang.Object> params,
   DataflowWriteChannel<T> target)
Taps into the pipeline. 
 | 
<V> Promise<V> | 
DataflowQueue.then(PGroup group,
    groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
<V> Promise<V> | 
DataflowReadChannel.then(PGroup group,
    groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
<V> Promise<V> | 
Promise.then(PGroup group,
    groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
<V> Promise<V> | 
DataflowVariable.then(PGroup group,
    groovy.lang.Closure<V> closure,
    groovy.lang.Closure<V> errorHandler)
Schedule closure to be executed after data becomes available. 
 | 
<V> Promise<V> | 
LazyDataflowVariable.then(PGroup group,
    groovy.lang.Closure<V> closure,
    groovy.lang.Closure<V> errorHandler)
Schedule closure to be executed after data becomes available. 
 | 
<V> Promise<V> | 
Promise.then(PGroup group,
    groovy.lang.Closure<V> closure,
    groovy.lang.Closure<V> errorHandler)
Schedule closure to be executed after data becomes available. 
 | 
Promise<java.util.List> | 
Promise.thenForkAndJoin(PGroup group,
               groovy.lang.Closure<? extends java.lang.Object>... closures)
Schedule a set of closures to be executed after data became available on the current promise. 
 | 
static java.lang.Object | 
Dataflow.usingGroup(PGroup group,
          groovy.lang.Closure code)
Sets the supplied PGroup as the default for the given block of code. 
 | 
<V> void | 
DataflowQueue.whenBound(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> void | 
DataflowReadChannel.whenBound(PGroup group,
         groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
<V> void | 
Promise.whenBound(PGroup group,
         groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
<V> void | 
SyncDataflowStreamReadAdapter.whenBound(PGroup group,
         groovy.lang.Closure<V> closure)  | 
| Constructor and Description | 
|---|
DataCallback(groovy.lang.Closure code,
            PGroup pGroup)  | 
LazyDataflowVariable(PGroup group,
                    groovy.lang.Closure<T> initializer)
Creates a new unbound Lazy Dataflow Variable with specific a PGroup to use for running the initializer 
 | 
Select(PGroup pGroup,
      java.util.List<SelectableChannel<? extends T>> channels)  | 
Select(PGroup pGroup,
      SelectableChannel<? extends T>... channels)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
DataflowExpression.binaryChoice(PGroup group,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)  | 
void | 
DataflowExpression.binaryChoice(PGroup group,
            java.util.Map<java.lang.String,java.lang.Object> params,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)  | 
<V> DataflowReadChannel<V> | 
DataflowExpression.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowExpression.chainWith(PGroup group,
         java.util.Map<java.lang.String,java.lang.Object> params,
         groovy.lang.Closure<V> closure)  | 
void | 
DataflowExpression.choice(PGroup group,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)  | 
void | 
DataflowExpression.choice(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)  | 
private Promise<java.util.List> | 
DataflowExpression.doThenForkAndJoin(PGroup group,
                 Pool pool,
                 groovy.lang.Closure<? extends java.lang.Object>[] closures)  | 
DataflowReadChannel<T> | 
DataflowExpression.filter(PGroup group,
      groovy.lang.Closure<java.lang.Boolean> closure)  | 
DataflowReadChannel<T> | 
DataflowExpression.filter(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      groovy.lang.Closure<java.lang.Boolean> closure)  | 
void | 
DataflowExpression.into(PGroup group,
    DataflowWriteChannel<T> target)  | 
void | 
DataflowExpression.into(PGroup group,
    java.util.Map<java.lang.String,java.lang.Object> params,
    DataflowWriteChannel<T> target)  | 
<V> DataflowReadChannel<V> | 
DataflowExpression.merge(PGroup group,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowExpression.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowExpression.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowExpression.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
void | 
DataflowExpression.separate(PGroup group,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)  | 
void | 
DataflowExpression.separate(PGroup group,
        java.util.Map<java.lang.String,java.lang.Object> params,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)  | 
void | 
DataflowExpression.split(PGroup group,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)  | 
void | 
DataflowExpression.split(PGroup group,
     java.util.List<DataflowWriteChannel<T>> targets)  | 
void | 
DataflowExpression.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)  | 
void | 
DataflowExpression.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowWriteChannel<T>> targets)  | 
DataflowReadChannel<T> | 
DataflowExpression.tap(PGroup group,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
DataflowExpression.tap(PGroup group,
   java.util.Map<java.lang.String,java.lang.Object> params,
   DataflowWriteChannel<T> target)  | 
<V> Promise<V> | 
DataflowExpression.then(PGroup group,
    groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
Promise<java.util.List> | 
DataflowExpression.thenForkAndJoin(PGroup group,
               groovy.lang.Closure<? extends java.lang.Object>... closures)
Schedule a set of closures to be executed after data became available on the current promise. 
 | 
<V> void | 
DataflowExpression.whenBound(PGroup group,
         groovy.lang.Closure<V> closure)
Schedule closure to be executed by pooled actor after data becomes available. 
 | 
| Constructor and Description | 
|---|
SelectBase(PGroup pGroup,
          java.util.List<SelectableChannel<? extends T>> channels)
Stores the input channel and registers for the wheneverBound() event on each 
 | 
| Modifier and Type | Field and Description | 
|---|---|
private PGroup | 
Pipeline.group  | 
| Modifier and Type | Method and Description | 
|---|---|
PGroup | 
Pipeline.getGroup()  | 
| Modifier and Type | Method and Description | 
|---|---|
DataflowProcessor | 
DataflowProcessor.start(PGroup group)
Starts a processor using the specified parallel group 
 | 
| Constructor and Description | 
|---|
DataflowOperator(PGroup group,
                java.util.Map channels,
                groovy.lang.Closure code)
Creates an operator
 After creation the operator needs to be started using the start() method. 
 | 
DataflowOperatorActor(DataflowOperator owningOperator,
                     PGroup group,
                     java.util.List outputs,
                     java.util.List inputs,
                     groovy.lang.Closure code)  | 
DataflowPrioritySelector(PGroup group,
                        java.util.Map<java.lang.String,java.lang.Object> channels,
                        groovy.lang.Closure code)
Creates a priority selector
 After creation the selector needs to be started using the start() method. 
 | 
DataflowProcessorActor(DataflowProcessor owningProcessor,
                      PGroup group,
                      java.util.List outputs,
                      java.util.List inputs,
                      groovy.lang.Closure code)  | 
DataflowSelector(PGroup group,
                java.util.Map channels,
                groovy.lang.Closure code)
Creates a selector
 After creation the selector needs to be started using the start() method. 
 | 
DataflowSelectorActor(DataflowSelector owningOperator,
                     PGroup group,
                     java.util.List outputs,
                     java.util.List inputs,
                     groovy.lang.Closure code)  | 
ForkingDataflowOperatorActor(DataflowOperator owningOperator,
                            PGroup group,
                            java.util.List outputs,
                            java.util.List inputs,
                            groovy.lang.Closure code,
                            int maxForks)  | 
ForkingDataflowSelectorActor(DataflowSelector owningOperator,
                            PGroup group,
                            java.util.List outputs,
                            java.util.List inputs,
                            groovy.lang.Closure code,
                            int maxForks)  | 
Pipeline(PGroup group,
        DataflowReadChannel output)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
DataflowStreamReadAdapter.binaryChoice(PGroup group,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)  | 
void | 
DataflowStreamReadAdapter.binaryChoice(PGroup group,
            java.util.Map<java.lang.String,java.lang.Object> params,
            DataflowWriteChannel<T> trueBranch,
            DataflowWriteChannel<T> falseBranch,
            groovy.lang.Closure<java.lang.Boolean> code)  | 
<V> DataflowReadChannel<V> | 
DataflowStreamReadAdapter.chainWith(PGroup group,
         groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowStreamReadAdapter.chainWith(PGroup group,
         java.util.Map<java.lang.String,java.lang.Object> params,
         groovy.lang.Closure<V> closure)  | 
void | 
DataflowStreamReadAdapter.choice(PGroup group,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)  | 
void | 
DataflowStreamReadAdapter.choice(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      java.util.List<DataflowWriteChannel<T>> outputs,
      groovy.lang.Closure<java.lang.Integer> code)  | 
DataflowReadChannel<T> | 
DataflowStreamReadAdapter.filter(PGroup group,
      groovy.lang.Closure<java.lang.Boolean> closure)  | 
DataflowReadChannel<T> | 
DataflowStreamReadAdapter.filter(PGroup group,
      java.util.Map<java.lang.String,java.lang.Object> params,
      groovy.lang.Closure<java.lang.Boolean> closure)  | 
void | 
DataflowStreamReadAdapter.into(PGroup group,
    DataflowWriteChannel<T> target)  | 
void | 
DataflowStreamReadAdapter.into(PGroup group,
    java.util.Map<java.lang.String,java.lang.Object> params,
    DataflowWriteChannel<T> target)  | 
<V> DataflowReadChannel<V> | 
DataflowStreamReadAdapter.merge(PGroup group,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowStreamReadAdapter.merge(PGroup group,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowStreamReadAdapter.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowReadChannel<java.lang.Object> other,
     groovy.lang.Closure<V> closure)  | 
<V> DataflowReadChannel<V> | 
DataflowStreamReadAdapter.merge(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowReadChannel<java.lang.Object>> others,
     groovy.lang.Closure<V> closure)  | 
void | 
DataflowStreamReadAdapter.separate(PGroup group,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)  | 
void | 
DataflowStreamReadAdapter.separate(PGroup group,
        java.util.Map<java.lang.String,java.lang.Object> params,
        java.util.List<DataflowWriteChannel<?>> outputs,
        groovy.lang.Closure<java.util.List<java.lang.Object>> code)  | 
void | 
DataflowStreamReadAdapter.split(PGroup group,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)  | 
void | 
DataflowStreamReadAdapter.split(PGroup group,
     java.util.List<DataflowWriteChannel<T>> targets)  | 
void | 
DataflowStreamReadAdapter.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     DataflowWriteChannel<T> target1,
     DataflowWriteChannel<T> target2)  | 
void | 
DataflowStreamReadAdapter.split(PGroup group,
     java.util.Map<java.lang.String,java.lang.Object> params,
     java.util.List<DataflowWriteChannel<T>> targets)  | 
DataflowReadChannel<T> | 
DataflowStreamReadAdapter.tap(PGroup group,
   DataflowWriteChannel<T> target)  | 
DataflowReadChannel<T> | 
DataflowStreamReadAdapter.tap(PGroup group,
   java.util.Map<java.lang.String,java.lang.Object> params,
   DataflowWriteChannel<T> target)  | 
<V> Promise<V> | 
DataflowStreamReadAdapter.then(PGroup group,
    groovy.lang.Closure<V> closure)
Schedule closure to be executed after data becomes available. 
 | 
<V> void | 
DataflowStreamReadAdapter.whenBound(PGroup group,
         groovy.lang.Closure<V> closure)  | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DefaultPGroup
Provides logical grouping for actors, agents and dataflow tasks and operators. 
 | 
class  | 
NonDaemonPGroup
Provides logical grouping for actors, agents and dataflow tasks and operators. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static PGroup | 
PGroupBuilder.createFromPool(jsr166y.ForkJoinPool pool)
Builds a PGroup instance from a ForkJoinPool instance 
 | 
static PGroup | 
PGroupBuilder.createFromPool(Pool pool)
Builds a PGroup instance from a Pool instance 
 | 
static PGroup | 
PGroupBuilder.createFromPool(java.util.concurrent.ThreadPoolExecutor pool)
Builds a PGroup instance from a ThreadPoolExecutor instance 
 |