added forgottne files

Author: rssh

src/main/scala/gopher/channels/BaseBufferedChannelActor.scala

@@ -0,0 +1,52 @@
+package gopher.channels
+
+import akka.actor._
+import scala.language._
+import scala.concurrent._
+import scala.collection.immutable._
+import gopher._
+
+
+/**
+ * ChannelActor - actor, which leave
+ */
+abstract class BaseBufferedChannelActor[A](id:Long, api: GopherAPI) extends ChannelActor[A](id,api)
+{
+
+  def processReaders() : Boolean =
+  { 
+    var retval = false
+    while(!readers.isEmpty && nElements > 0) {
+      val current = readers.head
+      readers = readers.tail
+      retval ||= processReader(current)
+    }
+    retval
+  }
+
+  def stopIfEmpty: Boolean =
+  {
+   require(closed==true)
+   if (nElements == 0) {
+      stopReaders()
+   }
+   stopWriters()
+   if (nElements == 0) {
+      if (nRefs == 0) {
+        // here we leave 'closed' channels in actor-system untile they will be
+        // garbage-collected.  TODO: think about actual stop ?
+        self ! GracefullChannelStop
+      }
+      true
+   } else
+      false
+  }
+
+  protected[this] def processReader[B](reader:ContRead[A,B]): Boolean 
+ 
+
+  protected[this] def getNElements(): Int = nElements
+
+  protected[this] var nElements=0
+
+}

src/main/scala/gopher/goasync/AsyncWrapper.scala

@@ -0,0 +1,35 @@
+package gopher.goasync
+
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox.Context
+import scala.reflect.api._
+import scala.concurrent._
+
+object AsyncWrapper
+{
+
+   def async[T](x:T)(implicit ec:ExecutionContext):Future[T] = macro asyncImpl[T]
+
+   def await[T](x:Future[T]):T = macro awaitImpl[T]
+
+   def postWrap[T](x:T):T = macro postWrapImpl[T]
+   
+   def asyncImpl[T](c:Context)(x:c.Expr[T])(ec:c.Expr[ExecutionContext]):c.Expr[Future[T]] =
+   {
+    import c.universe._
+    c.Expr[Future[T]](q"gopher.goasync.AsyncWrapper.postWrap(scala.async.Async.async(${x})(${ec}))")
+   }
+
+   def awaitImpl[T](c:Context)(x:c.Expr[Future[T]]):c.Expr[T] =
+   {
+    import c.universe._
+    c.Expr[T](q"gopher.goasync.AsyncWrapper.postWrap(scala.async.Async.await(${x}))")
+   }
+
+   def postWrapImpl[T](c:Context)(x:c.Expr[T]):c.Expr[T]=
+   {
+    import c.universe._
+    x
+   }
+
+}