PGroup (org.codehaus.gpars)

groovyx.gpars.group.PGroup

Provides a common super class of pooled parallel groups.
Authors:
Vaclav Pech, Alex Tkachman Date: May 8, 2009

Field Summary

Fields
Modifiers	Name	Description
`protected static java.lang.String`	`A_SPLITTER_NEEDS_AN_INPUT_CHANNEL_AND_AT_LEAST_ONE_OUTPUT_CHANNEL_TO_BE_CREATED`
`private Pool`	`threadPool`	Stores the group actors' thread pool

Constructor Summary

Constructors
Constructor and description
`protected PGroup (Pool threadPool)` Creates a group for actors, agents, tasks and operators.

Methods Summary

Methods
Type	Name and description
`DefaultActor`	`actor(java.lang.Runnable handler)` Creates a new instance of DefaultActor, using the passed-in runnable/closure as the body of the actor's act() method.
`Agent<T>`	`agent(T state)` Creates an agent instance initialized with the given state
`Agent<T>`	`agent(T state, groovy.lang.Closure copy)` Creates an agent instance initialized with the given state
`BlockingActor`	`blockingActor(java.lang.Runnable handler)` Creates a new instance of BlockingActor, using the passed-in closure as the body of the actor's act() method.
`void`	`execute(java.lang.Runnable task)` schedules a new task for processing with the pool
`DefaultActor`	`fairActor(java.lang.Runnable handler)` Creates a new instance of DefaultActor, using the passed-in runnable/closure as the body of the actor's act() method.
`Agent<T>`	`fairAgent(T state)` Creates an agent instance initialized with the given state, which will cooperate in thread sharing with other agents and actors in a fair manner.
`Agent<T>`	`fairAgent(T state, groovy.lang.Closure copy)` Creates an agent instance initialized with the given state, which will cooperate in thread sharing with other agents and actors in a fair manner.
`Actor`	`fairMessageHandler(groovy.lang.Closure code)` Creates an instance of DynamicDispatchActor, which will cooperate in thread sharing with other actors sharing the same thread pool
`Actor`	`fairReactor(groovy.lang.Closure code)` Creates a reactor around the supplied code, which will cooperate in thread sharing with other actors sharing the same thread pool When a reactor receives a message, the supplied block of code is run with the message as a parameter and the result of the code is send in reply.
`Actor`	`fairStaticMessageHandler(groovy.lang.Closure code)` Creates an instance of StaticDispatchActor, which will cooperate in thread sharing with other actors sharing the same thread pool.
`protected void`	`finalize()` Shutdown the thread pool gracefully
`int`	`getPoolSize()` Retrieves the current thread pool size
`Pool`	`getThreadPool()`
`private static boolean`	`isListAccepting(groovy.lang.Closure<T> code)`
`Promise<T>`	`lazyTask(groovy.lang.Closure<T> code)` Creates a new task assigned to a thread from the current parallel group.
`Promise<T>`	`lazyTask(java.util.concurrent.Callable<T> callable)` Creates a new task assigned to a thread from the current parallel group.
`Actor`	`messageHandler(groovy.lang.Closure code)` Creates an instance of DynamicDispatchActor.
`DataflowProcessor`	`operator(java.util.Map channels, groovy.lang.Closure code)` Creates an operator using the current parallel group
`DataflowProcessor`	`operator(java.util.List inputChannels, java.util.List outputChannels, groovy.lang.Closure code)` Creates an operator using the current parallel group
`DataflowProcessor`	`operator(java.util.List inputChannels, java.util.List outputChannels, int maxForks, groovy.lang.Closure code)` Creates an operator using the current parallel group
`DataflowProcessor`	`operator(DataflowReadChannel input, DataflowWriteChannel output, groovy.lang.Closure code)` Creates an operator using the current parallel group
`DataflowProcessor`	`operator(DataflowReadChannel input, DataflowWriteChannel output, int maxForks, groovy.lang.Closure code)` Creates an operator using the current parallel group
`DataflowProcessor`	`prioritySelector(java.util.Map channels, groovy.lang.Closure code)` Creates a prioritizing selector using the default dataflow parallel group Input with lower position index have higher priority.
`DataflowProcessor`	`prioritySelector(java.util.List inputChannels, java.util.List outputChannels, groovy.lang.Closure code)` Creates a prioritizing selector using the default dataflow parallel group Input with lower position index have higher priority.
`DataflowProcessor`	`prioritySelector(java.util.Map channels)` Creates a prioritizing selector using the default dataflow parallel group.
`DataflowProcessor`	`prioritySelector(java.util.List inputChannels, java.util.List outputChannels)` Creates a prioritizing selector using the default dataflow parallel group.
`Actor`	`reactor(groovy.lang.Closure code)` Creates a reactor around the supplied code.
`void`	`resetDefaultSize()` Sets the pool size to the default
`void`	`resize(int poolSize)` Resizes the thread pool to the specified value
`Select`	`select(SelectableChannel... channels)` Creates a select using the current parallel group.
`Select`	`select(java.util.List<? extends SelectableChannel> channels)` Creates a select using the current parallel group.
`DataflowProcessor`	`selector(java.util.Map channels, groovy.lang.Closure code)` Creates a selector using this parallel group
`DataflowProcessor`	`selector(java.util.List inputChannels, java.util.List outputChannels, groovy.lang.Closure code)` Creates a selector using this parallel group
`DataflowProcessor`	`selector(java.util.Map channels)` Creates a selector using this parallel group.
`DataflowProcessor`	`selector(java.util.List inputChannels, java.util.List outputChannels)` Creates a selector using this parallel group.
`private boolean`	`shallHandle(groovy.lang.Closure<T> errorHandler, java.lang.Throwable e)`
`void`	`shutdown()` Gently stops the pool
`DataflowProcessor`	`splitter(DataflowReadChannel inputChannel, java.util.List<DataflowWriteChannel> outputChannels)` Creates a splitter copying its single input channel into all of its output channels.
`DataflowProcessor`	`splitter(DataflowReadChannel inputChannel, java.util.List<DataflowWriteChannel> outputChannels, int maxForks)` Creates a splitter copying its single input channel into all of its output channels.
`Actor`	`staticMessageHandler(groovy.lang.Closure code)` Creates an instance of StaticDispatchActor.
`Promise<T>`	`task(groovy.lang.Closure<T> code)` Creates a new task assigned to a thread from the current parallel group.
`Promise<T>`	`task(java.util.concurrent.Callable<T> callable)` Creates a new task assigned to a thread from the current parallel group.
`Promise<java.lang.Object>`	`task(java.lang.Runnable code)` Creates a new task assigned to a thread from the current parallel group.
`Promise<T>`	`whenAllBound(java.util.List<Promise> promises, groovy.lang.Closure<T> code)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, groovy.lang.Closure<T> code)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, Promise promise2, groovy.lang.Closure<T> code)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, Promise promise2, Promise promise3, groovy.lang.Closure<T> code)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, Promise promise2, Promise promise3, Promise promise4, groovy.lang.Closure<T> code)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(java.util.List<Promise> promises, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, Promise promise2, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, Promise promise2, Promise promise3, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`Promise<T>`	`whenAllBound(Promise promise1, Promise promise2, Promise promise3, Promise promise4, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)` Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
`private void`	`whenAllBound(java.util.List<Promise> promises, int index, java.util.List<java.lang.Object> values, DataflowVariable<T> result, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)` Waits for the promise identified by the index to be bound and then passes on to the next promise in the list

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class java.lang.Object`	`java.lang.Object#wait(), java.lang.Object#wait(long, int), java.lang.Object#wait(long), java.lang.Object#equals(java.lang.Object), java.lang.Object#toString(), java.lang.Object#hashCode(), java.lang.Object#getClass(), java.lang.Object#notify(), java.lang.Object#notifyAll()`

- Field Detail
  - protected static final java.lang.String A_SPLITTER_NEEDS_AN_INPUT_CHANNEL_AND_AT_LEAST_ONE_OUTPUT_CHANNEL_TO_BE_CREATED
  - private final Pool threadPool
    
    Stores the group actors' thread pool
- Constructor Detail
  - protected PGroup(Pool threadPool)
    
    Creates a group for actors, agents, tasks and operators. The actors will share a common daemon thread pool.
    Parameters:
    threadPool - The thread pool to use by the group
- Method Detail
  - public final DefaultActor actor(@groovy.lang.DelegatesTo(DefaultActor.class) java.lang.Runnable handler)
    
    Creates a new instance of DefaultActor, using the passed-in runnable/closure as the body of the actor's act() method. The created actor will belong to the pooled parallel group.
    Returns:
    A newly created instance of the DefaultActor class
    Parameters:
    handler - The body of the newly created actor's act method.
  - public final Agent<T> agent(T state)
    
    Creates an agent instance initialized with the given state
    Returns:
    The created instance
    Parameters:
    state - The initial internal state of the new Agent instance
  - public final Agent<T> agent(T state, groovy.lang.Closure copy)
    
    Creates an agent instance initialized with the given state
    Returns:
    The created instance
    Parameters:
    state - The initial internal state of the new Agent instance
    copy - A closure to use to create a copy of the internal state when sending the internal state out
  - public final BlockingActor blockingActor(@groovy.lang.DelegatesTo(BlockingActor.class) java.lang.Runnable handler)
    
    Creates a new instance of BlockingActor, using the passed-in closure as the body of the actor's act() method. The created actor will be part of the default actor group.
    Returns:
    A newly created instance of the BlockingActor class
    Parameters:
    handler - The body of the newly created actor's act method.
  - public void execute(java.lang.Runnable task)
    
    schedules a new task for processing with the pool
    Parameters:
    task - The task to schedule
  - public final DefaultActor fairActor(@groovy.lang.DelegatesTo(DefaultActor.class) java.lang.Runnable handler)
    
    Creates a new instance of DefaultActor, using the passed-in runnable/closure as the body of the actor's act() method. The actor will cooperate in thread sharing with other actors sharing the same thread pool in a fair manner. The created actor will belong to the pooled parallel group.
    Returns:
    A newly created instance of the DefaultActor class
    Parameters:
    handler - The body of the newly created actor's act method.
  - public final Agent<T> fairAgent(T state)
    
    Creates an agent instance initialized with the given state, which will cooperate in thread sharing with other agents and actors in a fair manner.
    Returns:
    The created instance
    Parameters:
    state - The initial internal state of the new Agent instance
  - public final Agent<T> fairAgent(T state, groovy.lang.Closure copy)
    
    Creates an agent instance initialized with the given state, which will cooperate in thread sharing with other agents and actors in a fair manner.
    Returns:
    The created instance
    Parameters:
    copy - A closure to use to create a copy of the internal state when sending the internal state out
    state - The initial internal state of the new Agent instance
  - public final Actor fairMessageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)
    
    Creates an instance of DynamicDispatchActor, which will cooperate in thread sharing with other actors sharing the same thread pool
    Returns:
    The new started actor
    Parameters:
    code - The closure specifying individual message handlers.
  - public final Actor fairReactor(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)
    
    Creates a reactor around the supplied code, which will cooperate in thread sharing with other actors sharing the same thread pool When a reactor receives a message, the supplied block of code is run with the message as a parameter and the result of the code is send in reply.
    Returns:
    A new instance of ReactiveEventBasedThread
    Parameters:
    code - The code to invoke for each received message
  - public final Actor fairStaticMessageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)
    
    Creates an instance of StaticDispatchActor, which will cooperate in thread sharing with other actors sharing the same thread pool.
    Returns:
    The new started actor
    Parameters:
    code - The closure specifying the only statically dispatched message handler.
  - @java.lang.SuppressWarnings({"FinalizeDeclaration"}) @java.lang.Override protected void finalize()
    
    Shutdown the thread pool gracefully
  - public int getPoolSize()
    
    Retrieves the current thread pool size
    Returns:
    The pool size
  - public Pool getThreadPool()
  - private static boolean isListAccepting(groovy.lang.Closure<T> code)
  - public final Promise<T> lazyTask(groovy.lang.Closure<T> code)
    
    Creates a new task assigned to a thread from the current parallel group. The task is lazy, since it only gets executed if the returned Promise instance is read or a then-callback is registered on it. Tasks are a lightweight version of dataflow operators, which do not define their communication channels explicitly, but can only exchange data using explicit DataflowVariables and Streams. Registers itself with Dataflow for nested 'whenBound' handlers to use the same group.
    Returns:
    A LazyDataflowVariable, which gets assigned the value returned from the supplied code
    Parameters:
    code - The task body to run
  - public final Promise<T> lazyTask(java.util.concurrent.Callable<T> callable)
    
    Creates a new task assigned to a thread from the current parallel group. The task is lazy, since it only gets executed if the returned Promise instance is read or a then-callback is registered on it. Tasks are a lightweight version of dataflow operators, which do not define their communication channels explicitly, but can only exchange data using explicit DataflowVariables and Streams. Registers itself with Dataflow for nested 'whenBound' handlers to use the same group.
    Returns:
    A LazyDataflowVariable, which gets assigned the value returned from the supplied code
    Parameters:
    callable - The task body to run
  - public final Actor messageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)
    
    Creates an instance of DynamicDispatchActor.
    Returns:
    The new started actor
    Parameters:
    code - The closure specifying individual message handlers.
  - public final DataflowProcessor operator(java.util.Map channels, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)
    
    Creates an operator using the current parallel group
    Returns:
    A new started operator instance with all the channels set
    Parameters:
    channels - A map specifying "inputs" and "outputs" - dataflow channels (instances of the DataflowQueue or DataflowVariable classes) to use for inputs and outputs
    code - The operator's body to run each time all inputs have a value to read
  - public final DataflowProcessor operator(java.util.List inputChannels, java.util.List outputChannels, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)
    
    Creates an operator using the current parallel group
    Returns:
    A new started operator instance with all the channels set
    Parameters:
    inputChannels - dataflow channels to use for input
    outputChannels - dataflow channels to use for output
    code - The operator's body to run each time all inputs have a value to read
  - public final DataflowProcessor operator(java.util.List inputChannels, java.util.List outputChannels, int maxForks, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)
    
    Creates an operator using the current parallel group
    Returns:
    A new started operator instance with all the channels set
    Parameters:
    inputChannels - dataflow channels to use for input
    outputChannels - dataflow channels to use for output
    maxForks - Number of parallel threads running operator's body, defaults to 1
    code - The operator's body to run each time all inputs have a value to read
  - public final DataflowProcessor operator(DataflowReadChannel input, DataflowWriteChannel output, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)
    
    Creates an operator using the current parallel group
    Returns:
    A new started operator instance with all the channels set
    Parameters:
    input - a dataflow channel to use for input
    output - a dataflow channel to use for output
    code - The operator's body to run each time all inputs have a value to read
  - public final DataflowProcessor operator(DataflowReadChannel input, DataflowWriteChannel output, int maxForks, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)
    
    Creates an operator using the current parallel group
    Returns:
    A new started operator instance with all the channels set
    Parameters:
    input - a dataflow channel to use for input
    output - a dataflow channel to use for output
    maxForks - Number of parallel threads running operator's body, defaults to 1
    code - The operator's body to run each time all inputs have a value to read
  - public final DataflowProcessor prioritySelector(java.util.Map channels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)
    
    Creates a prioritizing selector using the default dataflow parallel group Input with lower position index have higher priority.
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    channels - A map specifying "inputs" and "outputs" - dataflow channels (instances of the DataflowQueue or DataflowVariable classes) to use for inputs and outputs
    code - The selector's body to run each time a value is available in any of the inputs channels
  - public final DataflowProcessor prioritySelector(java.util.List inputChannels, java.util.List outputChannels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)
    
    Creates a prioritizing selector using the default dataflow parallel group Input with lower position index have higher priority.
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    inputChannels - dataflow channels to use for input
    outputChannels - dataflow channels to use for output
    code - The selector's body to run each time a value is available in any of the inputs channels
  - public final DataflowProcessor prioritySelector(java.util.Map channels)
    
    Creates a prioritizing selector using the default dataflow parallel group. Since no body is provided, the selector will simply copy the incoming values to all output channels. Input with lower position index have higher priority.
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    channels - A map specifying "inputs" and "outputs" - dataflow channels (instances of the DataflowQueue or DataflowVariable classes) to use for inputs and outputs
  - public final DataflowProcessor prioritySelector(java.util.List inputChannels, java.util.List outputChannels)
    
    Creates a prioritizing selector using the default dataflow parallel group. Since no body is provided, the selector will simply copy the incoming values to all output channels. Input with lower position index have higher priority.
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    inputChannels - dataflow channels to use for input
    outputChannels - dataflow channels to use for output
  - public final Actor reactor(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)
    
    Creates a reactor around the supplied code. When a reactor receives a message, the supplied block of code is run with the message as a parameter and the result of the code is send in reply.
    Returns:
    A new instance of ReactiveEventBasedThread
    Parameters:
    code - The code to invoke for each received message
  - public void resetDefaultSize()
    
    Sets the pool size to the default
  - public void resize(int poolSize)
    
    Resizes the thread pool to the specified value
    Parameters:
    poolSize - The new pool size
  - public final Select select(SelectableChannel... channels)
    
    Creates a select using the current parallel group. The returns Select instance will allow the user to obtain values from the supplied dataflow variables or streams as they become available.
    Parameters:
    channels - Dataflow variables or streams to wait for values on
  - public final Select select(java.util.List<? extends SelectableChannel> channels)
    
    Creates a select using the current parallel group. The returns Select instance will allow the user to obtain values from the supplied dataflow variables or streams as they become available.
    Parameters:
    channels - Dataflow variables or streams to wait for values on
  - public final DataflowProcessor selector(java.util.Map channels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)
    
    Creates a selector using this parallel group
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    channels - A map specifying "inputs" and "outputs" - dataflow channels (instances of the DataflowQueue or DataflowVariable classes) to use for inputs and outputs
    code - The selector's body to run each time a value is available in any of the inputs channels
  - public final DataflowProcessor selector(java.util.List inputChannels, java.util.List outputChannels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)
    
    Creates a selector using this parallel group
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    inputChannels - dataflow channels to use for input
    outputChannels - dataflow channels to use for output
    code - The selector's body to run each time a value is available in any of the inputs channels
  - public final DataflowProcessor selector(java.util.Map channels)
    
    Creates a selector using this parallel group. Since no body is provided, the selector will simply copy the incoming values to all output channels.
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    channels - A map specifying "inputs" and "outputs" - dataflow channels (instances of the DataflowQueue or DataflowVariable classes) to use for inputs and outputs
  - public final DataflowProcessor selector(java.util.List inputChannels, java.util.List outputChannels)
    
    Creates a selector using this parallel group. Since no body is provided, the selector will simply copy the incoming values to all output channels.
    Returns:
    A new started selector instance with all the channels set
    Parameters:
    inputChannels - dataflow channels to use for input
    outputChannels - dataflow channels to use for output
  - private boolean shallHandle(groovy.lang.Closure<T> errorHandler, java.lang.Throwable e)
  - public void shutdown()
    
    Gently stops the pool
  - public final DataflowProcessor splitter(DataflowReadChannel inputChannel, java.util.List<DataflowWriteChannel> outputChannels)
    
    Creates a splitter copying its single input channel into all of its output channels. The created splitter will be part of this parallel group
    Returns:
    A new started splitter instance with all the channels set
    Parameters:
    inputChannel - The channel to read values from
    outputChannels - A list of channels to output to
  - public final DataflowProcessor splitter(DataflowReadChannel inputChannel, java.util.List<DataflowWriteChannel> outputChannels, int maxForks)
    
    Creates a splitter copying its single input channel into all of its output channels. The created splitter will be part of this parallel group
    Returns:
    A new started splitter instance with all the channels set
    Parameters:
    inputChannel - The channel to read values from
    outputChannels - A list of channels to output to
    maxForks - Number of threads running the splitter's body, defaults to 1
  - public final Actor staticMessageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)
    
    Creates an instance of StaticDispatchActor.
    Returns:
    The new started actor
    Parameters:
    code - The closure specifying the only statically dispatched message handler.
  - public final Promise<T> task(groovy.lang.Closure<T> code)
    
    Creates a new task assigned to a thread from the current parallel group. Tasks are a lightweight version of dataflow operators, which do not define their communication channels explicitly, but can only exchange data using explicit DataflowVariables and Streams. Registers itself with Dataflow for nested 'whenBound' handlers to use the same group.
    Returns:
    A DataflowVariable, which gets assigned the value returned from the supplied code
    Parameters:
    code - The task body to run
  - public final Promise<T> task(java.util.concurrent.Callable<T> callable)
    
    Creates a new task assigned to a thread from the current parallel group. Tasks are a lightweight version of dataflow operators, which do not define their communication channels explicitly, but can only exchange data using explicit DataflowVariables and Streams. Registers itself with Dataflow for nested 'whenBound' handlers to use the same group.
    Returns:
    A DataflowVariable, which gets assigned the value returned from the supplied code
    Parameters:
    callable - The task body to run
  - public final Promise<java.lang.Object> task(java.lang.Runnable code)
    
    Creates a new task assigned to a thread from the current parallel group. Tasks are a lightweight version of dataflow operators, which do not define their communication channels explicitly, but can only exchange data using explicit DataflowVariables and Streams. Registers itself with Dataflow for nested 'whenBound' handlers to use the same group.
    Returns:
    A DataflowVariable, which gets bound to null once the supplied code finishes
    Parameters:
    code - The task body to run
  - public final Promise<T> whenAllBound(java.util.List<Promise> promises, groovy.lang.Closure<T> code)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promises - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, groovy.lang.Closure<T> code)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, Promise promise2, groovy.lang.Closure<T> code)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    promise2 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, groovy.lang.Closure<T> code)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    promise2 - The promises to wait for
    promise3 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, Promise promise4, groovy.lang.Closure<T> code)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    promise2 - The promises to wait for
    promise3 - The promises to wait for
    promise4 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    - The type of the final result
  - public final Promise<T> whenAllBound(java.util.List<Promise> promises, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promises - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    errorHandler - A closure handling an exception (an instance of Throwable), if it gets bound
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    errorHandler - A closure handling an exception (an instance of Throwable), if if it gets bound
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, Promise promise2, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    promise2 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    errorHandler - A closure handling an exception (an instance of Throwable), if if it gets bound
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    promise2 - The promises to wait for
    promise3 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    errorHandler - A closure handling an exception (an instance of Throwable), if if it gets bound
    - The type of the final result
  - public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, Promise promise4, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)
    
    Without blocking the thread waits for all the promises to get bound and then passes them to the supplied closure.
    Returns:
    A promise for the final result
    Parameters:
    promise1 - The promises to wait for
    promise2 - The promises to wait for
    promise3 - The promises to wait for
    promise4 - The promises to wait for
    code - A closure to execute with concrete values for each of the supplied promises
    errorHandler - A closure handling an exception (an instance of Throwable), if if it gets bound
    - The type of the final result
  - private void whenAllBound(java.util.List<Promise> promises, int index, java.util.List<java.lang.Object> values, DataflowVariable<T> result, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)
    
    Waits for the promise identified by the index to be bound and then passes on to the next promise in the list
    Parameters:
    promises - A list of all promises that need to be waited for
    index - The index of the current promise to wait for
    values - A list of values the so-far processed promises were bound tpo
    result - The promise for the final result of the calculation
    code - The calculation to execute on the values once they are all bound
    - The type of the final result

Summary:
Field
Constructor
Method

| Detail:
Field
Constructor
Method

[Java] Class PGroup

Field Summary

Constructor Summary

Methods Summary

Inherited Methods Summary

Field Detail

protected static final java.lang.String A_SPLITTER_NEEDS_AN_INPUT_CHANNEL_AND_AT_LEAST_ONE_OUTPUT_CHANNEL_TO_BE_CREATED

private final Pool threadPool

Constructor Detail

protected PGroup(Pool threadPool)

Method Detail

public final DefaultActor actor(@groovy.lang.DelegatesTo(DefaultActor.class) java.lang.Runnable handler)

public final Agent<T> agent(T state)

public final Agent<T> agent(T state, groovy.lang.Closure copy)

public final BlockingActor blockingActor(@groovy.lang.DelegatesTo(BlockingActor.class) java.lang.Runnable handler)

public void execute(java.lang.Runnable task)

public final DefaultActor fairActor(@groovy.lang.DelegatesTo(DefaultActor.class) java.lang.Runnable handler)

public final Agent<T> fairAgent(T state)

public final Agent<T> fairAgent(T state, groovy.lang.Closure copy)

public final Actor fairMessageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)

public final Actor fairReactor(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)

public final Actor fairStaticMessageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)

@java.lang.SuppressWarnings({"FinalizeDeclaration"}) @java.lang.Override protected void finalize()

public int getPoolSize()

public Pool getThreadPool()

private static boolean isListAccepting(groovy.lang.Closure<T> code)

public final Promise<T> lazyTask(groovy.lang.Closure<T> code)

public final Promise<T> lazyTask(java.util.concurrent.Callable<T> callable)

public final Actor messageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)

public final DataflowProcessor operator(java.util.Map channels, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)

public final DataflowProcessor operator(java.util.List inputChannels, java.util.List outputChannels, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)

public final DataflowProcessor operator(java.util.List inputChannels, java.util.List outputChannels, int maxForks, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)

public final DataflowProcessor operator(DataflowReadChannel input, DataflowWriteChannel output, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)

public final DataflowProcessor operator(DataflowReadChannel input, DataflowWriteChannel output, int maxForks, @groovy.lang.DelegatesTo(DataflowOperator.class) groovy.lang.Closure code)

public final DataflowProcessor prioritySelector(java.util.Map channels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)

public final DataflowProcessor prioritySelector(java.util.List inputChannels, java.util.List outputChannels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)

public final DataflowProcessor prioritySelector(java.util.Map channels)

public final DataflowProcessor prioritySelector(java.util.List inputChannels, java.util.List outputChannels)

public final Actor reactor(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)

public void resetDefaultSize()

public void resize(int poolSize)

public final Select select(SelectableChannel... channels)

public final Select select(java.util.List<? extends SelectableChannel> channels)

public final DataflowProcessor selector(java.util.Map channels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)

public final DataflowProcessor selector(java.util.List inputChannels, java.util.List outputChannels, @groovy.lang.DelegatesTo(DataflowSelector.class) groovy.lang.Closure code)

public final DataflowProcessor selector(java.util.Map channels)

public final DataflowProcessor selector(java.util.List inputChannels, java.util.List outputChannels)

private boolean shallHandle(groovy.lang.Closure<T> errorHandler, java.lang.Throwable e)

public void shutdown()

public final DataflowProcessor splitter(DataflowReadChannel inputChannel, java.util.List<DataflowWriteChannel> outputChannels)

public final DataflowProcessor splitter(DataflowReadChannel inputChannel, java.util.List<DataflowWriteChannel> outputChannels, int maxForks)

public final Actor staticMessageHandler(@groovy.lang.DelegatesTo(Actor.class) groovy.lang.Closure code)

public final Promise<T> task(groovy.lang.Closure<T> code)

public final Promise<T> task(java.util.concurrent.Callable<T> callable)

public final Promise<java.lang.Object> task(java.lang.Runnable code)

public final Promise<T> whenAllBound(java.util.List<Promise> promises, groovy.lang.Closure<T> code)

public final Promise<T> whenAllBound(Promise promise1, groovy.lang.Closure<T> code)

public final Promise<T> whenAllBound(Promise promise1, Promise promise2, groovy.lang.Closure<T> code)

public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, groovy.lang.Closure<T> code)

public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, Promise promise4, groovy.lang.Closure<T> code)

public final Promise<T> whenAllBound(java.util.List<Promise> promises, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)

public final Promise<T> whenAllBound(Promise promise1, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)

public final Promise<T> whenAllBound(Promise promise1, Promise promise2, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)

public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)

public final Promise<T> whenAllBound(Promise promise1, Promise promise2, Promise promise3, Promise promise4, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)

private void whenAllBound(java.util.List<Promise> promises, int index, java.util.List<java.lang.Object> values, DataflowVariable<T> result, groovy.lang.Closure<T> code, groovy.lang.Closure<T> errorHandler)