more documentation

Author: rssh

shared/src/main/scala/gopher/Select.scala

@@ -107,14 +107,6 @@ class Select[F[_]](api: Gopher[F]):
   transparent inline def aforever(inline pf: PartialFunction[Any,Unit]): F[Unit] =
     ${  SelectMacro.aforeverImpl('pf, 'api)  }
 
-  /*  
-  transparent inline def aforever_async(inline pf: PartialFunction[Any,F[Unit]]): F[Unit] =
-      given CpsSchedulingMonad[F] = api.asyncMonad
-      async(using api.asyncMonad).apply {
-        val runner = new SelectForever[F](api)
-        runner.applyAsync(pf)
-      }
-  */  
 
 
 

shared/src/main/scala/gopher/SelectForever.scala

@@ -7,7 +7,7 @@ import scala.concurrent.duration._
 
 
 /**
- * forever Apply
+ * Result of `select.forever`: apply method accept partial pseudofunction which evalueated forever.
  **/
 class SelectForever[F[_]](api: Gopher[F]) extends SelectGroupBuilder[F,Unit, Unit](api):
 
@@ -17,10 +17,6 @@ class SelectForever[F[_]](api: Gopher[F]) extends SelectGroupBuilder[F,Unit, Uni
       SelectMacro.foreverImpl('pf,'api)
     }
 
-  transparent inline def applyAsync(inline pf: PartialFunction[Any,Unit]): F[Unit] =
-    ${
-      SelectMacro.aforeverImpl('pf, 'api)
-    }
 
   def runAsync(): F[Unit] = 
     given CpsSchedulingMonad[F] = api.asyncMonad

shared/src/main/scala/gopher/SelectGroup.scala

@@ -14,8 +14,18 @@ import java.util.logging.{Level => LogLevel}
 
 
 /**
- * Select group is a virtual 'lock' object, where only
- * ne fro rieader and writer can exists at the sae time.
+ * Select group is a virtual 'lock' object.
+ * Readers and writers are grouped into select groups. When
+ * event about avaiability to read or to write is arrived and 
+ * no current event group members is running, than run of one of the members
+ * is triggered.
+ * I.e. only one from group can run.
+ *
+ * Note, that application develeper usually not work with `SelectGroup` directly, 
+ * it is created internally by `select`  pseudostatement.
+ * 
+ *@see [gopher.Select]
+ *@see [gopher.select]
  **/
 class SelectGroup[F[_], S](api: Gopher[F])  extends SelectListeners[F,S,S]: 
 
@@ -28,10 +38,10 @@ class SelectGroup[F[_], S](api: Gopher[F])  extends SelectListeners[F,S,S]:
      * 2 - expired
      **/
     val waitState: AtomicInteger = new AtomicInteger(0)
-    var call: Try[S] => Unit = { _ => () }
+    private var call: Try[S] => Unit = { _ => () }
     private inline def m = api.asyncMonad
-    val retval = m.adoptCallbackStyle[S](f => call=f)
-    val startTime = new AtomicLong(0L)
+    private val retval = m.adoptCallbackStyle[S](f => call=f)
+    private val startTime = new AtomicLong(0L)
     var timeoutScheduled: Option[Time.Scheduled] = None
 
     override def asyncMonad = api.asyncMonad  

shared/src/main/scala/gopher/SelectMacro.scala

@@ -38,7 +38,7 @@ object SelectMacro:
         '{  $base.onRead($ch.done)($f) }
 
 
-  def selectListenerBuilder1[F[_]:Type, S:Type, R:Type, L <: SelectListeners[F,S,R]:Type](
+  def selectListenerBuilder[F[_]:Type, S:Type, R:Type, L <: SelectListeners[F,S,R]:Type](
       constructor: Expr[L], 
       caseDefs: List[SelectorCaseExpr[F,S,R]])(using Quotes): Expr[L] =
         val s0 = constructor
@@ -51,7 +51,7 @@ object SelectMacro:
            constructor: Expr[L], 
            caseDefs: List[SelectorCaseExpr[F,S,R]], 
            api:Expr[Gopher[F]])(using Quotes): Expr[R] =
-            val g = selectListenerBuilder1(constructor, caseDefs)
+            val g = selectListenerBuilder(constructor, caseDefs)
             //  dotty bug if g.run
             val r = '{ await($g.runAsync())(using ${api}.asyncMonad) } 
             r.asExprOf[R]
@@ -60,7 +60,7 @@ object SelectMacro:
               constructor: Expr[L], 
               caseDefs: List[SelectorCaseExpr[F,S,R]], 
               api:Expr[Gopher[F]])(using Quotes): Expr[F[R]] =
-                val g = selectListenerBuilder1(constructor, caseDefs)
+                val g = selectListenerBuilder(constructor, caseDefs)
                 //  dotty bug if g.run
                 val r = '{ $g.runAsync() } 
                 r.asExprOf[F[R]]