pekko/akka-patterns/src/main/scala/Patterns.scala

package se.scalablesolutions.akka.actor.patterns

import se.scalablesolutions.akka.actor.Actor

object Patterns {
  type PF[A,B] = PartialFunction[A,B]

  /**
   * Creates a new PartialFunction whose isDefinedAt is a combination
   * of the two parameters, and whose apply is first to call filter.apply and then filtered.apply
   */
  def filter[A,B](filter : PF[A,Unit],filtered : PF[A,B]) : PF[A,B] = {
    case a : A if filtered.isDefinedAt(a) && filter.isDefinedAt(a) =>
      filter(a)
      filtered(a)
  }

  /**
   * Interceptor is a filter(x,y) where x.isDefinedAt is considered to be always true
   */
  def intercept[A,B](interceptor : (A) => Unit, interceptee : PF[A,B]) : PF[A,B] = filter(
      { case a if a.isInstanceOf[A] => interceptor(a) },
      interceptee
    )
  
  //FIXME 2.8, use default params with CyclicIterator
  def loadBalancerActor(actors :  => InfiniteIterator[Actor]) : Actor = new Actor with LoadBalancer {
    val seq = actors
  }

  def dispatcherActor(routing : PF[Any,Actor], msgTransformer : (Any) => Any) : Actor = new Actor with Dispatcher {
        override def transform(msg : Any) = msgTransformer(msg)
    def routes = routing
  }
  
  def dispatcherActor(routing : PF[Any,Actor]) : Actor = new Actor with Dispatcher {
        def routes = routing
  }

  def loggerActor(actorToLog : Actor, logger : (Any) => Unit) : Actor = dispatcherActor (
    { case _ => actorToLog },
    logger
  )
}

trait Dispatcher { self : Actor =>

  protected def transform(msg : Any) : Any = msg
  protected def routes : PartialFunction[Any,Actor]
  
  protected def dispatch : PartialFunction[Any,Unit] = {
    case a if routes.isDefinedAt(a) => {
      if(self.sender.isDefined)
        routes(a) forward transform(a)
      else
        routes(a) send transform(a)
    }
  }

  def receive = dispatch
}

trait LoadBalancer extends Dispatcher { self : Actor =>
  protected def seq : InfiniteIterator[Actor]

  protected def routes = { case x if seq.hasNext => seq.next }
}

trait InfiniteIterator[T] extends Iterator[T]

class CyclicIterator[T](items : List[T]) extends InfiniteIterator[T] {
  @volatile private[this] var current : List[T] = items
  def hasNext = items != Nil
  def next = {
    val nc = if(current == Nil) items else current
    current = nc.tail
    nc.head
  }
}