org.d_haven.event.impl
Class MultiCastSink

java.lang.Object
  extended byorg.d_haven.event.impl.MultiCastSink
All Implemented Interfaces:
Sink

public class MultiCastSink
extends java.lang.Object
implements Sink

This is a Sink implementation that multicasts enqueue operations to the contained and concrete sink objects. The multi cast sink will try to enqueue and only succeeds if no element was rejected from any sink. The sink can be configured to enqueue into one sink alone or all sinks. If a sink array in the collection of sinks contains more than one sink the multicast sink will try to enqueue the element always to only one of these sinks.

Version:
$Revision: 1.11 $
Author:
schierma

Constructor Summary
MultiCastSink(java.util.Collection sinks)
          This constructor creates a failure in-tolerant multicast sink based on the collection of sink arrays.
MultiCastSink(java.util.Collection sinks, boolean single)
          This constructor creates a failure in-tolerant multicast sink based on the collection of sink arrays.
 
Method Summary
 void enqueue(java.lang.Object element)
          Enqueues the given element onto the Sink.
 void enqueue(java.lang.Object[] elements)
          Given an array of elements, atomically enqueues all of the elements in the array.
 PreparedEnqueue prepareEnqueue(java.lang.Object[] elements)
          Support for transactional enqueue.
 int size()
          Returns the number of elements waiting in this Sink.
 java.lang.String toString()
           
 boolean tryEnqueue(java.lang.Object element)
          Tries to enqueue an event, but instead of throwing exceptions, it returns a boolean value of whether the attempt was successful.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Constructor Detail

MultiCastSink

public MultiCastSink(java.util.Collection sinks)
This constructor creates a failure in-tolerant multicast sink based on the collection of sink arrays. The delivery must succeed for all sinks in the collection or it will fail entirely.

Parameters:
sinks - A collection of sink arrays for each stage.
Since:
May 16, 2002

MultiCastSink

public MultiCastSink(java.util.Collection sinks,
                     boolean single)
This constructor creates a failure in-tolerant multicast sink based on the collection of sink arrays.

Parameters:
sinks - A collection of sink arrays for each stage.
single - true if just one operation must succeed. false if all operations must succeed.
Since:
May 16, 2002
Method Detail

enqueue

public void enqueue(java.lang.Object element)
             throws SinkException
Description copied from interface: Sink
Enqueues the given element onto the Sink.

Specified by:
enqueue in interface Sink
Parameters:
element - The elements to enqueue
Throws:
SinkException

enqueue

public void enqueue(java.lang.Object[] elements)
             throws SinkException
Description copied from interface: Sink
Given an array of elements, atomically enqueues all of the elements in the array. This guarantees that no other thread can interleave its own elements with those being inserted from this array. The implementation must enqueue all of the elements or none of them; if a SinkFullException or SinkClosedException is thrown, none of the elements will have been enqueued.

Specified by:
enqueue in interface Sink
Parameters:
elements - The element array to enqueue
Throws:
SinkException

tryEnqueue

public boolean tryEnqueue(java.lang.Object element)
Description copied from interface: Sink
Tries to enqueue an event, but instead of throwing exceptions, it returns a boolean value of whether the attempt was successful.

Specified by:
tryEnqueue in interface Sink
Parameters:
element - The element to attempt to enqueue
Returns:
true if successful, false if not.

prepareEnqueue

public PreparedEnqueue prepareEnqueue(java.lang.Object[] elements)
                               throws SinkException
Description copied from interface: Sink
Support for transactional enqueue.

This method allows a client to provisionally enqueue a number of elements onto the queue, and then later commit the enqueue (with a commitEnqueue call), or abort (with an abortEnqueue call). This mechanism can be used to perform "split-phase" enqueues, where a client first enqueues a set of elements on the queue and then performs some work to "fill in" those elements before performing a commit. This can also be used to perform multi-queue transactional enqueue operations, with an "all-or-nothing" strategy for enqueueing events on multiple Sinks.

This method would generally be used in the following manner:

   PreparedEnqueue enqueue = sink.prepareEnqueue(someElements);
   if (canCommit) {
     enqueue.commit();
   } else {
     enqueue.abort();
   }
 

Note that this method does not protect against "dangling prepares" -- that is, a prepare without an associated commit or abort operation. This method should be used with care. In particular, be sure that all code paths (such as exceptions) after a prepare include either a commit or an abort.

Specified by:
prepareEnqueue in interface Sink
Parameters:
elements - The element array to provisionally enqueue
Returns:
A PreparedEnqueue that may be used to commit or abort the provisional enqueue
Throws:
SinkException
See Also:
PreparedEnqueue

size

public int size()
Description copied from interface: Sink
Returns the number of elements waiting in this Sink.

Important: The contract for this method was updated to account for any elements that were prepared for enqueueing. It provides a more predictable and consistent environment, as well as making it easier for EnqueuePredicates to account for those elements.

Specified by:
size in interface Sink
Returns:
the number of elements in the Sink

toString

public java.lang.String toString()


Copyright © 2004-2007 D-Haven.org. All Rights Reserved.