Removing actors-migration from main repository so it can live on elsewhere.

* Removes actors-migration hooks from partest
* Removes actors-migration code
* removes actors-migration tests
* removes actors-migration distribution packaging.

1 files changed, 0 insertions, 74 deletions

diff --git a/src/actors/scala/actors/ActorRef.scala b/src/actors/scala/actors/ActorRef.scala
index cca78b0832..5c1790669b 100644
--- a/src/actors/scala/actors/ActorRef.scala
+++ b/src/actors/scala/actors/ActorRef.scala
@@ -2,8 +2,6 @@ package scala.actors
 
 import java.util.concurrent.TimeoutException
 import scala.concurrent.duration.Duration
-import scala.concurrent.Promise
-import scala.concurrent.ExecutionContext.Implicits.global
 
 /**
  * Trait used for migration of Scala actors to Akka.
@@ -43,78 +41,6 @@ trait ActorRef {
 
 }
 
-private[actors] class OutputChannelRef(val actor: OutputChannel[Any]) extends ActorRef {
-
-  override private[actors] def ?(message: Any, timeout: Duration): scala.concurrent.Future[Any] =
-    throw new UnsupportedOperationException("Output channel does not support ?")
-
-  /**
-   * Sends a one-way asynchronous message. E.g. fire-and-forget semantics.
-   * <p/>
-   *
-   * <p/>
-   * <pre>
-   *   actor ! message
-   * </pre>
-   * <p/>
-   */
-  def !(message: Any)(implicit sender: ActorRef = null): Unit =
-    if (sender != null)
-      actor.send(message, sender.localActor)
-    else
-      actor ! message
-
-  override def equals(that: Any) =
-    that.isInstanceOf[OutputChannelRef] && that.asInstanceOf[OutputChannelRef].actor == this.actor
-
-  private[actors] override def localActor: AbstractActor =
-    throw new UnsupportedOperationException("Output channel does not have an instance of the actor")
-
-  def forward(message: Any): Unit = throw new UnsupportedOperationException("OutputChannel does not support forward.")
-
-}
-
-private[actors] class ReactorRef(override val actor: Reactor[Any]) extends OutputChannelRef(actor) {
-
-  /**
-   * Forwards the message and passes the original sender actor as the sender.
-   * <p/>
-   * Works with '!' and '?'.
-   */
-  override def forward(message: Any) = actor.forward(message)
-
-}
-
-private[actors] final class InternalActorRef(override val actor: InternalActor) extends ReactorRef(actor) {
-
-  /**
-   * Sends a message asynchronously, returning a future which may eventually hold the reply.
-   */
-  override private[actors] def ?(message: Any, timeout: Duration): scala.concurrent.Future[Any] = {
-    val dur = if (timeout.isFinite()) timeout.toMillis else (java.lang.Long.MAX_VALUE >> 2)
-    val replyPromise = Promise[Any]
-    scala.concurrent.future {
-      scala.concurrent.blocking {
-        actor !? (dur, message)
-      } match {
-        case Some(x) => replyPromise success x
-        case None => replyPromise failure new AskTimeoutException("? operation timed out.")
-      }
-    }
-    replyPromise.future
-  }
-
-  override def !(message: Any)(implicit sender: ActorRef = null): Unit =
-    if (message == PoisonPill)
-      actor.stop('normal)
-    else if (sender != null)
-      actor.send(message, sender.localActor)
-    else
-      actor ! message
-
-  private[actors] override def localActor: InternalActor = this.actor
-}
-
 /**
  * This is what is used to complete a Future that is returned from an ask/? call,
  * when it times out.