.13.e.source-code.repeater.scala Maven / Gradle / Ivy

Go to download
/*
   Copyright 2010 Aaron J. Radke

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
package cc.drx

 //note: the cc.drx.ScheduledContext is used here instead the aliased java.util.concurrent.ScheduledThreadPoolExecutor to provide a more drx focused implicit not found message provided in the cc.drx package object
import cc.drx.{ScheduledContext => SC} //using this alias for schedule executor provides better missing implicit warning messagse than the one for java
import java.util.concurrent.ScheduledFuture
import java.util.concurrent.TimeUnit.NANOSECONDS
import scala.concurrent.Promise

//TODO replace the sleeping loops in cc.drx.Time with this schedule based delays from the Repeater

//--schedulers
// import java.util.concurrent.{ScheduledThreadPoolExecutor, TimeUnit}
//https://docs.scala-lang.org/overviews/core/futures.html
//maybe something like the following:
//https://stackoverflow.com/a/37737385/622016  (uses scheduled exec Implicit.sc)
//https://stackoverflow.com/a/16363444/622016 (uses java.util.Timer tasks

/* TODO implement with a java timer so the scheduler is not required https://stackoverflow.com/a/16363444/622016 (uses java.util.Timer tasks
def delayTimer[A](f: => A)(implicit ex:ExecutionContext):Future[A] = {
  mkPromise{p => 
   ex.schedule(Java.Runnable(p complete Try(f)), ns.toLong, NANOSECONDS) 
  }
}
*/

/**a cancelable and scheduler based around drx.Time*/
object Repeater{
  private def mkPromise[A](f: Promise[A] => _):Future[A] = {val p = Promise[A]; f(p); p.future}
 
  def delay[A](t:Time, f: => A)(implicit ex:SC):Future[A] = 
    mkPromise{p => ex.schedule(Java.Runnable(p complete Try(f)), t.ns.toLong, NANOSECONDS) }
  def repeat(dt:Time, tEnd:Option[Time], f: => Unit)(implicit ex:SC) = new Repeater(
    ex.scheduleAtFixedRate(Java.Runnable(f), 0L, dt.ns.toLong, NANOSECONDS),
    tEnd
  )
  def repeatSpaced(dt:Time, tEnd:Option[Time], f: => Unit)(implicit ex:SC) = new Repeater(
    ex.scheduleWithFixedDelay(Java.Runnable(f), 0L, dt.ns.toLong, NANOSECONDS),
    tEnd
  )
}
class Repeater[A]( sf: ScheduledFuture[A], timeout:Option[Time]=None)(implicit ex:SC){
  //TODO add built in counters
  // private val t0 = System.nanoTime
  timeout.foreach{_ delay stop}  //if timout exits use the time.delay to schedule a stop
  def stop:Unit = {sf.cancel(true); ()}
}