/**
   * Create an anchor tag around a body which will do an AJAX call and invoke the function
   *
   * @param jsFunc -- the user function that will be executed. This function will receive as last parameter
   *                  the function that will actually do the ajax call. Hence the user function can decide when
   * 				  to make the ajax request.
   * @param func - the function to invoke when the link is clicked
   * @param body - the NodeSeq to wrap in the anchor tag
   * @param attrs - the anchor node attributes
   */
  def a(jsFunc: Call, func: () =>; JsCmd, body: NodeSeq, attrs: (String, String)*): Elem = {
    attrs.foldLeft(fmapFunc(contextFuncBuilder(func))(name =>;
            <a onclick="{deferCall(Str(name" href="javascript://">{body}</a>))(_ % _)
  }

function delete(toDelete) {
  if (confirm("Delete?"))
    toDelete()
}

class MyException(message: String, cause: Throwable) extends Exception(message, cause) {
  def this(message: String): = this(message, null)
  def this(cause: Throwable): = this(null, cause)
  def this: = this(null, null)
}

object SpcException {
  def apply(message: String, cause: Throwable): Exception =
    (new SpcException1(message, cause)).asInstanceOf[Exception]
 
  def apply(message: String): Exception =
    (new SpcException2(message)).asInstanceOf[Exception]
 
  def apply(cause: Throwable): Exception =
    (new SpcException3(cause)).asInstanceOf[Exception]
 
  def apply(): Exception =
    (new SpcException4).asInstanceOf[Exception]
}
 
trait SpcException
 
class SpcException1(message: String, cause: Throwable)
    extends Exception(message, cause) with SpcException
 
class SpcException2(message: String)
    extends Exception(message) with SpcException
 
class SpcException3(cause: Throwable)
    extends Exception(cause) with SpcException
 
class SpcException4 extends Exception with SpcException

  def start(): Actor = synchronized {
    // Reset various flags.
    //
    // Note that we do *not* reset `trapExit`. The reason is that
    // users should be able to set the field in the constructor
    // and before `act` is called.
 
    exitReason = 'normal
    exiting = false
    shouldExit = false
 
    scheduler execute {
      ActorGC.newActor(Actor.this)
      (new Reaction(Actor.this)).run()
    }
 
    this
  }

  def receive[R](f: PartialFunction[Any, R]): R = {
    assert(Actor.self == this, "receive from channel belonging to other actor")
    this.synchronized {
      if (shouldExit) exit() // links
      val qel = mailbox.extractFirst((m: Any) => f.isDefinedAt(m))
      if (null eq qel) {
        waitingFor = f.isDefinedAt
        isSuspended = true
        suspendActor()
      } else {
        received = Some(qel.msg)
        sessions = qel.session :: sessions
      }
      waitingFor = waitingForNone
      isSuspended = false
    }
    val result = f(received.get)
    sessions = sessions.tail
    result
  }

  def react(f: PartialFunction[Any, Unit]): Nothing = {
    assert(Actor.self == this, "react on channel belonging to other actor")
    this.synchronized {
      if (shouldExit) exit() // links
      val qel = mailbox.extractFirst((m: Any) => f.isDefinedAt(m))
      if (null eq qel) {
        waitingFor = f.isDefinedAt
        continuation = f
        isDetached = true
      } else {
        sessions = List(qel.session)
        scheduleActor(f, qel.msg)
      }
      throw new SuspendActorException
    }
  }

  def send(msg: Any, replyTo: OutputChannel[Any]) = synchronized {
    if (waitingFor(msg)) {
      received = Some(msg)
 
      if (isSuspended)
        sessions = replyTo :: sessions
      else
        sessions = List(replyTo)
 
      waitingFor = waitingForNone
 
      if (!onTimeout.isEmpty) {
        onTimeout.get.cancel()
        onTimeout = None
      }
 
      if (isSuspended)
        resumeActor()
      else // assert continuation != null
        scheduler.execute(new Reaction(this, continuation, msg))
    } else {
      mailbox.append(msg, replyTo)
    }