better diagnostics

Author: rssh

src/main/scala/gopher/GopherAPI.scala

@@ -30,9 +30,13 @@ class GopherAPI(as: ActorSystem, es: ExecutionContext)
    *  }
    * }}}
    */
-  def select: SelectFactory =
+  val select: SelectFactory =
     new SelectFactory(this)
 
+  /**
+   * Generic schema for making objects, which requiere gopherAPI for constructions.
+   *
+   **/
   def make[T](args: Any*): T = macro GopherAPI.makeImpl[T]
 
   /**

src/main/scala/gopher/channels/SelectorBuilder.scala

@@ -242,15 +242,15 @@ object SelectorBuilder
      import c.universe._
      cases map { cs =>
         cs.pat match {
-           case Bind(ident, t) => foreachTransformReadWriteCaseDef(c)(bn,cs)
+           case Bind(ident, t) => foreachTransformReadWriteTimeoutCaseDef(c)(bn,cs)
            case Ident(TermName("_")) => foreachTransformIdleCaseDef(c)(bn,cs)
            case _ => c.abort(cs.pat.pos,"expected Bind or Default in pattern, have:"+cs.pat)
         }
      }
    }
 
 
-   def foreachTransformReadWriteCaseDef(c:Context)(builderName:c.TermName, caseDef: c.universe.CaseDef):c.Tree=
+   def foreachTransformReadWriteTimeoutCaseDef(c:Context)(builderName:c.TermName, caseDef: c.universe.CaseDef):c.Tree=
    {
     import c.universe._
 
@@ -346,18 +346,27 @@ object SelectorBuilder
                     tpo match {
                        case Select(ch,TypeName("read")) =>
                                    if (!caseDef.guard.isEmpty) {
-                                     c.abort(caseDef.guard.pos,"guard is not supported in select case")
+                                     c.abort(caseDef.guard.pos,"guard is not supported in read in select case")
                                    }
                                    val reading = q"${builderName}.reading(${ch}){ ${param} => ${body} }"
-                                   reading
+                                   atPos(caseDef.pat.pos)(reading)
                        case Select(ch,TypeName("write")) =>
                                    val expression = if (!caseDef.guard.isEmpty) {
                                                       parseGuardInSelectorCaseDef(c)(termName,caseDef.guard)
                                                     } else {
-                                                      Ident(termName)
+                                                      atPos(caseDef.pat.pos)(Ident(termName))
                                                     }
                                    val writing = q"${builderName}.writing(${ch},${expression})(${param} => ${body} )"
-                                   writing
+                                   atPos(caseDef.pat.pos)(writing)
+                       case Select(select,TypeName("timeout")) =>
+                                   val expression = if (!caseDef.guard.isEmpty) {
+                                                      parseGuardInSelectorCaseDef(c)(termName,caseDef.guard)
+                                                    } else {
+                                                      atPos(caseDef.pat.pos)(q"implicitly[akka.util.Timeout]")
+                                                    }
+                                   val timeout = q"${builderName}.timeout(${expression})(${param} => ${body} )"
+                                   System.err.println(s"generate timeout statement: ${timeout}")
+                                   atPos(caseDef.pat.pos)(timeout)
                        case _ =>
                          if (caseDef.guard.isEmpty) {
                             c.abort(tp.pos, "row caseDef:"+showRaw(caseDef) );
@@ -396,7 +405,7 @@ object SelectorBuilder
                     }
                     c.abort(caseDef.pat.pos, s"match must be in form x:channel.write or x:channel.read, have: ${rawToShow}");
       case _ =>
-            c.abort(caseDef.pat.pos, "match must be in form x:channel.write or x:channel.read");
+            c.abort(caseDef.pat.pos, "match must be in form x:channel.write or x:channel.read or x:select.timeout");
     }
 
     retval

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

@@ -6,6 +6,7 @@ import scala.reflect.api._
 import gopher._
 import gopher.util._
 import scala.concurrent._
+import scala.concurrent.duration._
 import scala.annotation.unchecked._
 
 
@@ -23,6 +24,8 @@ class SelectFactory(val api: GopherAPI)
 
   selectFactory =>
 
+  type timeout = FiniteDuration
+
   trait SelectFactoryApi
   {
     def api = selectFactory.api

src/test/scala/gopher/channels/MacroSelectSuite.scala

@@ -335,6 +335,23 @@ class MacroSelectSuite extends FunSuite
      assert(x2.isInstanceOf[ChannelClosedException])
    }
 
+   test("select with constant timeout")  {
+     pending
+   /*
+     import gopherApi._
+     val ch1 = makeChannel[Int](10)
+     val r = select.amap {
+       case x:ch1.read =>
+                  System.err.println(s"readed ${x}")
+                  x
+       case x:select.timeout if (x==500.milliseconds) =>
+                 System.err.println(s"timeout 500 ms")
+                 -1
+     }
+     val f1 = ch1.awrite(1)
+    */
+   }
+
    lazy val gopherApi = CommonTestObjects.gopherApi
 
 }