org.squeryl.internals.PosoLifecycleEvent.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of squeryl_2.10 Show documentation
A Scala ORM and DSL for talking with Databases using minimum verbosity and maximum type safety
There is a newer version: 0.9.6-RC4
package org.squeryl.internals

import org.squeryl.{View, Schema}

object PosoLifecycleEvent extends Enumeration {
  type PosoLifeCycleEvent = Value
  val BeforeInsert, AfterInsert, BeforeDelete, AfterDelete, BeforeUpdate, AfterUpdate, AfterSelect, Create = Value
}

class LifecycleEventInvoker(i: Iterable[LifecycleEvent], owner: View[_]) extends PosoLifecycleEventListener {

  import PosoLifecycleEvent._

  private[this] val _beforeInsert = i.filter(_.e == BeforeInsert).map(_.callback)
  private[this] val _afterInsert = i.filter(_.e == AfterInsert).map(_.callback)
  private[this] val _beforeDelete = i.filter(_.e == BeforeDelete).map(_.callback)
  private[this] val _afterDelete = i.filter(_.e == AfterDelete).map(_.callback)
  private[this] val _beforeUpdate = i.filter(_.e == BeforeUpdate).map(_.callback)
  private[this] val _afterUpdate = i.filter(_.e == AfterUpdate).map(_.callback)
  private[this] val _afterSelect = i.filter(_.e == AfterSelect).map(_.callback)

  private[this] val _factory: AnyRef => AnyRef = {

    val f = i.filter(_.e == Create).map(_.callback)
    if (f.size > 1) org.squeryl.internals.Utils.throwError(owner.name + " has more than one factory defined.")
    f.headOption.getOrElse((r: AnyRef) => { null })
  }

  override def hasBeforeDelete = _beforeDelete != Nil
  override def hasAfterDelete = _afterDelete != Nil

  private def applyFuncs(fs: Iterable[AnyRef => AnyRef], a: AnyRef) = {

    var res = a

    for (f <- fs) {
      res = f(res)
    }

    res
  }

  def create: AnyRef = _factory(null)

  def beforeInsert(a: AnyRef) = applyFuncs(_beforeInsert, a)
  def afterInsert(a: AnyRef) = applyFuncs(_afterInsert, a)
  def beforeDelete(a: AnyRef) = applyFuncs(_beforeDelete, a)
  def afterDelete(a: AnyRef) = applyFuncs(_afterDelete, a)
  def beforeUpdate(a: AnyRef) = applyFuncs(_beforeUpdate, a)
  def afterUpdate(a: AnyRef) = applyFuncs(_afterUpdate, a)
  def afterSelect(a: AnyRef) = applyFuncs(_afterSelect, a)
}

trait BaseLifecycleEventPercursor {

  protected def createLCEMap[A](t: Iterable[View[_]], e: PosoLifecycleEvent.Value, f: A => A) =
    new LifecycleEvent(t, e, f.asInstanceOf[AnyRef => AnyRef])

  protected def createLCECall[A](t: Iterable[View[_]], e: PosoLifecycleEvent.Value, f: A => Unit) =
    createLCEMap[A](
      t,
      e,
      (ar: A) => {
        f(ar)
        ar
      }
    )
}

class PosoFactoryPercursorTable[A](target: View[_]) extends BaseLifecycleEventPercursor {
  def is(f: => A) = new LifecycleEvent(
    Seq(target),
    PosoLifecycleEvent.Create,
    (r: AnyRef) => {
      val a = f
      a.asInstanceOf[AnyRef]
    }
  )
}

class LifecycleEventPercursorTable[A](target: View[_], e: PosoLifecycleEvent.Value)
    extends BaseLifecycleEventPercursor {

  def call(f: A => Unit) = createLCECall(Seq(target), e, f)

  def map(a: A => A) = createLCEMap(Seq(target), e, a)
}

class LifecycleEventPercursorClass[A](target: Class[_], schema: Schema, e: PosoLifecycleEvent.Value)
    extends BaseLifecycleEventPercursor {

  def call(f: A => Unit) = createLCECall(schema.findAllTablesFor(target), e, f)

  def map(a: A => A) = createLCEMap(schema.findAllTablesFor(target), e, a)

}

class LifecycleEvent(val target: Iterable[View[_]], val e: PosoLifecycleEvent.Value, val callback: AnyRef => AnyRef)

trait PosoLifecycleEventListener {

  def hasBeforeDelete = false
  def hasAfterDelete = false
  def create: AnyRef
  def beforeInsert(a: AnyRef): AnyRef
  def afterInsert(a: AnyRef): AnyRef
  def beforeDelete(a: AnyRef): AnyRef
  def afterDelete(a: AnyRef): AnyRef
  def beforeUpdate(a: AnyRef): AnyRef
  def afterUpdate(a: AnyRef): AnyRef
  def afterSelect(a: AnyRef): AnyRef
}

object NoOpPosoLifecycleEventListener extends PosoLifecycleEventListener {
  def create: AnyRef = null
  def beforeInsert(a: AnyRef) = a
  def afterInsert(a: AnyRef) = a
  def beforeDelete(a: AnyRef) = a
  def afterDelete(a: AnyRef) = a
  def beforeUpdate(a: AnyRef) = a
  def afterUpdate(a: AnyRef) = a
  def afterSelect(a: AnyRef) = a
}