more specific names.

Author: rssh

src/main/scala/gopher/GopherAPI.scala

@@ -52,7 +52,7 @@ class GopherAPI(as: ActorSystem, es: ExecutionContext)
                               .asInstanceOf[Future[ActorRef]]
                             )
 
-     new ActorBackedChannel[A](futureChannelRef, this)
+     new ActorBackedBufferedChannel[A](futureChannelRef, this)
     }
 
   def makeEffectedInput[A](in: Input[A], threadingPolicy: ThreadingPolicy = ThreadingPolicy.Single) =

src/main/scala/gopher/channels/ActorBackedChannel.scala renamed to src/main/scala/gopher/channels/ActorBackedBufferedChannel.scala

@@ -11,7 +11,7 @@ import scala.language.postfixOps
 import scala.reflect.macros.blackbox.Context
 import scala.reflect.api._
 
-class ActorBackedChannel[A](futureChannelRef: Future[ActorRef], override val api: GopherAPI) extends Channel[A](api)
+class ActorBackedBufferedChannel[A](futureChannelRef: Future[ActorRef], override val api: GopherAPI) extends Channel[A](api)
 {
 
   def  cbread[B](f: ContRead[A,B] => Option[ContRead.In[A] => Future[Continuated[B]]], flwt: FlowTermination[B] ): Unit = 

src/main/scala/gopher/channels/ChannelActor.scala renamed to src/main/scala/gopher/channels/BufferedChannelActor.scala

@@ -6,52 +6,11 @@ import scala.concurrent._
 import scala.collection.immutable._
 import gopher._
 
-sealed trait ChannelActorMessage
-
-case object ChannelClose extends ChannelActorMessage
-
-/**
- * this is message wich send to ChannelActor, when we 
- * know, that channel is closed. In such case, we don't
- * konw: is actor stopped or not, So, we say this message
- * (instead read) and wait for reply. If reply is not received
- * within given timeout: think that channel is-dead.
- */
-case class ClosedChannelRead(cont: ContRead[_,_]) extends ChannelActorMessage
-
-/**
- * this message is send, when all references to 
- * some instance of this channel are unreachable, 
- * so if we have no other instances (i.e. remote 
- * channel incarnation), than we must destroy channel.
- **/
-case object ChannelRefDecrement extends ChannelActorMessage
-
-/**
- * this message is send, when we create new remote 
- * reference to channel, backed by this actor.
- **/
-case object ChannelRefIncrement extends ChannelActorMessage
-
-/**
- * result of CloseChannelRead, return number of elements
- * left to read
- */
-case class ChannelCloseProcessed(nElements: Int) extends ChannelActorMessage
-
-/**
- * When we decide to stop channel, do it via special message,
- * to process one after messages, which exists now in queue.
- *
- * Note, that channel-stop messages can be send only from ChannelActor
- */
-case object GracefullChannelStop extends ChannelActorMessage
-
 
 /**
  * ChannelActor - actor, which leave
  */
-class ChannelActor[A](id:Long, capacity:Int, api: GopherAPI) extends Actor
+class BufferedChannelActor[A](id:Long, capacity:Int, api: GopherAPI) extends Actor
 {
 
   def receive = {

src/main/scala/gopher/channels/ChannelActorMessage.scala

@@ -0,0 +1,45 @@
+package gopher.channels
+
+import scala.language.existentials
+
+sealed trait ChannelActorMessage
+
+case object ChannelClose extends ChannelActorMessage
+
+/**
+ * this is message wich send to ChannelActor, when we 
+ * know, that channel is closed. In such case, we don't
+ * konw: is actor stopped or not, So, we say this message
+ * (instead read) and wait for reply. If reply is not received
+ * within given timeout: think that channel is-dead.
+ */
+case class ClosedChannelRead(cont: ContRead[_,_]) extends ChannelActorMessage
+
+/**
+ * this message is send, when all references to 
+ * some instance of this channel are unreachable, 
+ * so if we have no other instances (i.e. remote 
+ * channel incarnation), than we must destroy channel.
+ **/
+case object ChannelRefDecrement extends ChannelActorMessage
+
+/**
+ * this message is send, when we create new remote 
+ * reference to channel, backed by this actor.
+ **/
+case object ChannelRefIncrement extends ChannelActorMessage
+
+/**
+ * result of CloseChannelRead, return number of elements
+ * left to read
+ */
+case class ChannelCloseProcessed(nElements: Int) extends ChannelActorMessage
+
+/**
+ * When we decide to stop channel, do it via special message,
+ * to process one after messages, which exists now in queue.
+ *
+ * Note, that channel-stop messages can be send only from ChannelActor
+ */
+case object GracefullChannelStop extends ChannelActorMessage
+

src/main/scala/gopher/channels/ChannelSupervisor.scala

@@ -12,7 +12,7 @@ class ChannelSupervisor(api: GopherAPI) extends Actor
 
    def receive = {
       case NewChannel(id,capacity) => 
-             val props = Props(classOf[ChannelActor[_]],id, capacity, api)
+             val props = Props(classOf[BufferedChannelActor[_]],id, capacity, api)
              sender ! context.actorOf(props, name=id.toString)
       case CloseChannel(id) =>
              context.actorSelection(id.toString) ! ChannelClose