From abc1a19fd4dee9729fd0aed721575a396d249bd4 Mon Sep 17 00:00:00 2001
From: matthew_swift <matthew_swift@localhost>
Date: Wed, 16 Dec 2009 22:13:34 +0000
Subject: [PATCH] Migrate remaining future impls over to new future APIs.

---
 sdk/src/org/opends/sdk/HeartBeatConnectionFactory.java |  130 ++++++-------------------------------------
 1 files changed, 19 insertions(+), 111 deletions(-)

diff --git a/sdk/src/org/opends/sdk/HeartBeatConnectionFactory.java b/sdk/src/org/opends/sdk/HeartBeatConnectionFactory.java
index 619f880..d917444 100644
--- a/sdk/src/org/opends/sdk/HeartBeatConnectionFactory.java
+++ b/sdk/src/org/opends/sdk/HeartBeatConnectionFactory.java
@@ -32,15 +32,12 @@
 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 
 import org.opends.sdk.requests.*;
 import org.opends.sdk.responses.*;
 import org.opends.sdk.schema.Schema;
 
+import com.sun.opends.sdk.util.FutureResultTransformer;
 import com.sun.opends.sdk.util.Validator;
 
 
@@ -437,126 +434,37 @@
 
 
 
-  private final class ResultFutureImpl implements
-      FutureResult<AsynchronousConnection>,
+  private final class FutureResultImpl
+      extends
+      FutureResultTransformer<AsynchronousConnection, AsynchronousConnection>
+      implements FutureResult<AsynchronousConnection>,
       ResultHandler<AsynchronousConnection>
   {
-    private volatile AsynchronousConnectionImpl heartBeatConnection;
 
-    private volatile ErrorResultException exception;
-
-    private volatile FutureResult<?> connectFuture;
-
-    private final CountDownLatch latch = new CountDownLatch(1);
-
-    private final ResultHandler<? super AsynchronousConnectionImpl> handler;
-
-    private boolean cancelled;
-
-
-
-    private ResultFutureImpl(
-        ResultHandler<? super AsynchronousConnectionImpl> handler)
+    private FutureResultImpl(
+        ResultHandler<? super AsynchronousConnection> handler)
     {
-      this.handler = handler;
+      super(handler);
     }
 
 
 
-    public boolean cancel(boolean mayInterruptIfRunning)
+    /**
+     * {@inheritDoc}
+     */
+    protected AsynchronousConnection transformResult(
+        AsynchronousConnection connection) throws ErrorResultException
     {
-      cancelled = connectFuture.cancel(mayInterruptIfRunning);
-      if (cancelled)
-      {
-        latch.countDown();
-      }
-      return cancelled;
-    }
-
-
-
-    public AsynchronousConnectionImpl get()
-        throws InterruptedException, ErrorResultException
-    {
-      latch.await();
-      if (cancelled)
-      {
-        throw new CancellationException();
-      }
-      if (exception != null)
-      {
-        throw exception;
-      }
-      return heartBeatConnection;
-    }
-
-
-
-    public AsynchronousConnectionImpl get(long timeout, TimeUnit unit)
-        throws InterruptedException, TimeoutException,
-        ErrorResultException
-    {
-      latch.await(timeout, unit);
-      if (cancelled)
-      {
-        throw new CancellationException();
-      }
-      if (exception != null)
-      {
-        throw exception;
-      }
-      return heartBeatConnection;
-    }
-
-
-
-    public boolean isCancelled()
-    {
-      return cancelled;
-    }
-
-
-
-    public boolean isDone()
-    {
-      return latch.getCount() == 0;
-    }
-
-
-
-    public int getRequestID()
-    {
-      return -1;
-    }
-
-
-
-    public void handleResult(AsynchronousConnection connection)
-    {
-      heartBeatConnection = new AsynchronousConnectionImpl(connection);
+      AsynchronousConnectionImpl heartBeatConnection = new AsynchronousConnectionImpl(
+          connection);
       synchronized (activeConnections)
       {
         connection.addConnectionEventListener(heartBeatConnection);
         activeConnections.add(heartBeatConnection);
       }
-      if (handler != null)
-      {
-        handler.handleResult(heartBeatConnection);
-      }
-      latch.countDown();
+      return heartBeatConnection;
     }
 
-
-
-    public void handleErrorResult(ErrorResultException error)
-    {
-      exception = error;
-      if (handler != null)
-      {
-        handler.handleErrorResult(error);
-      }
-      latch.countDown();
-    }
   }
 
 
@@ -564,9 +472,9 @@
   public FutureResult<AsynchronousConnection> getAsynchronousConnection(
       ResultHandler<? super AsynchronousConnection> handler)
   {
-    ResultFutureImpl future = new ResultFutureImpl(handler);
-    future.connectFuture = parentFactory
-        .getAsynchronousConnection(future);
+    FutureResultImpl future = new FutureResultImpl(handler);
+    future.setFutureResult(parentFactory
+        .getAsynchronousConnection(future));
     return future;
   }
 }

--
Gitblit v1.10.0