root/blogbird/src/main/scala/org/aiotrade/httpd/coactors.scala @ 263:4769869ad6f6

package org.aiotrade.httpd

import scala.actors.Actor
import scala.collection.mutable.ListBuffer

object ChainActor {
  /** a private case object None that will not accessable outside here */
  private case object None
  /** noneAction will never be matched since None is private */
  private val noneAction: PartialFunction[Any, Unit] = {case None => ()}
}

trait ChainActor extends Actor {
  protected val actorActions = new ListBuffer[PartialFunction[Any, Unit]]

  def stop {
    super.exit
  }

  def act = loop {
    react {
      chainReactions
    }
  }

  private def chainReactions: PartialFunction[Any, Unit] = 
    (ChainActor.noneAction /: actorActions)(_ orElse _)
}

/**
 * A O-producer is a coroutine that produces type-O objects for consumption by other coroutines.
 */
trait Producer[O] extends ChainActor {
  protected var consumer: Actor = _

  actorActions += {
    case output: O => consumer ! output
  }

  /**
   * Called by the coroutine's <code>run</code> method when it has produced a new output.
   */
  def produce(output: O) {
    consumer ! output
  }

  /**
   * Composes this producing coroutine with a transducing coroutine.
   *
   * @return A fused producing coroutine.
   */
  def ==>[O2](to: Transducer[O, O2]): Producer[O2] = {
    consumer = to
    to
  }

  /**
   * Composes this producing coroutine with a consuming coroutine.
   *
   * @return A fused coroutine.
   */
  def ==>(to: Consumer[O]): Actor = {
    consumer = to
    to
  }
}

/**
 * An I-consumer is a coroutine that consumes type-I objects.
 */
trait Consumer[I] extends ChainActor {

  actorActions += {
    case input: I => consume(input)
  }

  protected def consume(input: I)

}

/**
 * An I,O-transducer consumes type-I objects and produces type-O objects.
 */
trait Transducer[I, O] extends Consumer[I] with Producer[O]