implemented select.exit and select.shutdown

Author: rssh

src/main/scala/gopher/channels/Channel.scala

@@ -14,7 +14,6 @@ import scala.reflect.api._
 trait Channel[A] extends InputOutput[A]
 {
 
-
    def close(): Unit
 
 }

src/main/scala/gopher/channels/CurrentFlowTermination.scala

@@ -36,5 +36,11 @@ object CurrentFlowTermination
     c.Expr[Unit](q"implicitly[FlowTermination[Any]].doThrow(${e})")
    }
 
+   def shutdownImpl(c:Context)(): c.Expr[Unit] =
+   {
+    import c.universe._
+    exitImpl[Unit](c)(c.Expr[Unit](q"()"))
+   }
+
 
 }

src/main/scala/gopher/channels/SelectorFactory.scala

@@ -46,6 +46,17 @@ class SelectFactory(val api: GopherAPI)
    */
   def loop[A]: SelectorBuilder[A] = new SelectorBuilder[A] with SelectFactoryApi {}
 
+  /**
+   * afold - asynchronious version of fold.  
+   * {{{
+   *  select.afold((0,1)) { (s,(x,y)) =>
+   *    s match {
+   *      case x: out.write => (y,x+y)
+   *      case q: quit.read => select.exit((x,y))
+   *    }
+   *  }
+   * }}}
+   */
   def afold[S](s:S)(op:(S,Any)=>S):Future[S] = macro FoldSelectorBuilderImpl.afold[S]
 
   def fold[S](s:S)(op:(S,Any)=>S):S = macro FoldSelectorBuilderImpl.fold[S]
@@ -58,6 +69,11 @@ class SelectFactory(val api: GopherAPI)
   def amap[B](f:PartialFunction[Any,B]):Input[B] =
                                     macro SelectorBuilder.inputImpl[B]
 
+  //
+
+  def exit[A](a:A):A = macro CurrentFlowTermination.exitImpl[A]
+
+  def shutdown():Unit = macro CurrentFlowTermination.shutdownImpl
 
 }
 

src/test/scala/example/FibonaccyFoldSuite.scala

@@ -17,27 +17,27 @@ import gopher.tags._
 object FibonaccyFold {
 
   import scala.concurrent.ExecutionContext.Implicits.global
+  import CommonTestObjects.gopherApi._
 
   def fibonacci(c: Output[Long], quit: Input[Int]): Future[(Long,Long)] = 
-     gopherApi.select.afold((0L,1L)) { case ((x,y),s) =>
+     select.afold((0L,1L)) { case ((x,y),s) =>
       s match {
         case x: c.write =>  (y, x+y)
         case q: quit.read =>
-                 implicitly[FlowTermination[(Long,Long)]].doExit((x,y))
+                   select.exit((x,y))
       }
      }
 
   def run(n:Int, acceptor: Long => Unit ): Future[(Long,Long)] =
   {
-    val c = gopherApi.makeChannel[Long](1);
-    val quit = gopherApi.makeChannel[Int](1);
+    val c = makeChannel[Long](1);
+    val quit = makeChannel[Int](1);
     val r = c.map{ x =>
             //Console.println(s"${x} ")
             acceptor(x)}.atake(n) flatMap ( _ => (quit awrite 0) )
     fibonacci(c,quit)
   }
 
-  def gopherApi = CommonTestObjects.gopherApi 
 
 }
 

src/test/scala/gopher/channels/FlowTerminationSuite.scala

@@ -5,6 +5,7 @@ import org.scalatest._
 import scala.concurrent._
 import scala.concurrent.duration._
 import gopher._
+import scala.language.postfixOps
 
 import scala.concurrent.ExecutionContext.Implicits.global
 
@@ -59,9 +60,7 @@ class FlowTerminationSuite extends FunSuite
      var sum = 0
      val f = select.forever{
         case x: channel.read => sum += x
-                CurrentFlowTermination.exit(())
-                //TODO: implement syntax
-                //select.shutdown()
+                select.shutdown()
      }
      val f2 = channel.awrite(1) 
      Await.result(f, 1 second)