Molecule15

Instance Constructors

new Molecule15(_model: Model, _query: Query)

Type Members

case class AsOf(tx: TxType) extends DbOp with Product with Serializable

Definition Classes
DatomicFacade
sealed trait DbOp extends AnyRef

Definition Classes
DatomicFacade
case class Imagine(tx: List[AnyRef]) extends DbOp with Product with Serializable

Definition Classes
DatomicFacade
type KeepQueryOpsWhenFormatting = Int

Definition Classes
DatomicFacade
type Op[T] = Option[T]

Attributes
protected
Definition Classes
Molecule
case class Since(date: Date) extends DbOp with Product with Serializable

Definition Classes
DatomicFacade
sealed trait TxType extends AnyRef

Definition Classes
DatomicFacade
type W[Out] = ValueAttr[_, _, _, Out]

Attributes
protected
Definition Classes
Molecule
type lObj = List[AnyRef]

Attributes
protected
Definition Classes
Molecule
trait modelCheck extends AnyRef

Attributes
protected
Definition Classes
Molecule
case class txDate(txInstant: Date) extends TxType with Product with Serializable

Definition Classes
DatomicFacade
case class txLong(t: Long) extends TxType with Product with Serializable

Definition Classes
DatomicFacade
case class txlObj(tx: List[AnyRef]) extends TxType with Product with Serializable

Definition Classes
DatomicFacade

Abstract Value Members

abstract def debug(implicit conn: Connection): Unit

Definition Classes
Molecule
abstract def debugE(implicit conn: Connection): Unit

Definition Classes
Molecule
abstract def get(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
abstract def getE(implicit conn: Connection): Seq[(Long, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object History extends DbOp with Product with Serializable

Definition Classes
DatomicFacade
val _model: Model

Definition Classes
Molecule15 → Molecule
val _query: Query

Definition Classes
Molecule15 → Molecule
def add(implicit conn: Connection): Tx

Definition Classes
Molecule
implicit def anyToArgProperty[T](t: ⇒ T): ArgProperty[T]

Definition Classes
ArgProperties
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asOf(tx: lObj): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
def asOf(l: Long): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
def asOf(d: Date): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
def asOf_[M <: Molecule](thisMolecule: M, t: lObj): M

Attributes
protected
Definition Classes
Molecule
def asOf_[M <: Molecule](thisMolecule: M, l: Long): M

Attributes
protected
Definition Classes
Molecule
def asOf_[M <: Molecule](thisMolecule: M, d: Date): M

Attributes
protected
Definition Classes
Molecule
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def get(n: Int)(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def history: Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
def history_[M <: Molecule](thisMolecule: M): M

Attributes
protected
Definition Classes
Molecule
def imagine(tx: lObj): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
def imagine_[M <: Molecule](thisMolecule: M, tx: lObj): M

Attributes
protected
Definition Classes
Molecule
def inputs(query: Query): Seq[AnyRef]

Definition Classes
DatomicFacade
def insert(conn: Connection, model: Model, dataRows: Seq[Seq[Any]] = Seq()): Tx

Attributes
protected[molecule]
Definition Classes
DatomicFacade
object insert extends modelCheck
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def loadList(txlist: List[_], identifier: String = "", protocol: String = "mem"): Connection

Definition Classes
DatomicFacade
def maybe[T1, T2, T3, T4, T5, T6, T7](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4], v5: W[T5], v6: W[T6], v7: W[T7])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4], Op[T5], Op[T6], Op[T7])]
def maybe[T1, T2, T3, T4, T5, T6](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4], v5: W[T5], v6: W[T6])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4], Op[T5], Op[T6])]
def maybe[T1, T2, T3, T4, T5](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4], v5: W[T5])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4], Op[T5])]
def maybe[T1, T2, T3, T4](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4])]
def maybe[T1, T2, T3](v1: W[T1], v2: W[T2], v3: W[T3])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3])]
def maybe[T1, T2](v1: W[T1], v2: W[T2])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2])]
def maybe[T1](v1: W[T1])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1])]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def one(implicit conn: Connection): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
def recreateDbFrom(tx: Transaction, identifier: String = "", protocol: String = "mem"): Connection

Definition Classes
DatomicFacade
def results(conn: Connection, model: Model, query: Query): List[List[AnyRef]]

Definition Classes
DatomicFacade
def save(conn: Connection, model: Model): Tx

Attributes
protected[molecule]
Definition Classes
DatomicFacade
def since(d: Date): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
def since_[M <: Molecule](thisMolecule: M, date: Date): M

Attributes
protected
Definition Classes
Molecule
def some(implicit conn: Connection): Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Molecule → AnyRef → Any
def update(implicit conn: Connection): Tx

Definition Classes
Molecule
def update(conn: Connection, model: Model): Tx

Attributes
protected[molecule]
Definition Classes
DatomicFacade
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package api

abstract class Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Molecule

Instance Constructors

new Molecule15(_model: Model, _query: Query)

Type Members

case class AsOf(tx: TxType) extends DbOp with Product with Serializable

sealed trait DbOp extends AnyRef

case class Imagine(tx: List[AnyRef]) extends DbOp with Product with Serializable

type KeepQueryOpsWhenFormatting = Int

type Op[T] = Option[T]

case class Since(date: Date) extends DbOp with Product with Serializable

sealed trait TxType extends AnyRef

type W[Out] = ValueAttr[_, _, _, Out]

type lObj = List[AnyRef]

trait modelCheck extends AnyRef

case class txDate(txInstant: Date) extends TxType with Product with Serializable

case class txLong(t: Long) extends TxType with Product with Serializable

case class txlObj(tx: List[AnyRef]) extends TxType with Product with Serializable

Abstract Value Members

abstract def debug(implicit conn: Connection): Unit

abstract def debugE(implicit conn: Connection): Unit

abstract def get(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

abstract def getE(implicit conn: Connection): Seq[(Long, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object History extends DbOp with Product with Serializable

val _model: Model

val _query: Query

def add(implicit conn: Connection): Tx

implicit def anyToArgProperty[T](t: ⇒ T): ArgProperty[T]

final def asInstanceOf[T0]: T0

def asOf(tx: lObj): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

def asOf(l: Long): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

def asOf(d: Date): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

def asOf_[M <: Molecule](thisMolecule: M, t: lObj): M

def asOf_[M <: Molecule](thisMolecule: M, l: Long): M

def asOf_[M <: Molecule](thisMolecule: M, d: Date): M

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def get(n: Int)(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

final def getClass(): Class[_]

def hashCode(): Int

def history: Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

def history_[M <: Molecule](thisMolecule: M): M

def imagine(tx: lObj): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

def imagine_[M <: Molecule](thisMolecule: M, tx: lObj): M

def inputs(query: Query): Seq[AnyRef]

def insert(conn: Connection, model: Model, dataRows: Seq[Seq[Any]] = Seq()): Tx

object insert extends modelCheck

final def isInstanceOf[T0]: Boolean

def loadList(txlist: List[_], identifier: String = "", protocol: String = "mem"): Connection

def maybe[T1, T2, T3, T4, T5, T6, T7](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4], v5: W[T5], v6: W[T6], v7: W[T7])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4], Op[T5], Op[T6], Op[T7])]

def maybe[T1, T2, T3, T4, T5, T6](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4], v5: W[T5], v6: W[T6])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4], Op[T5], Op[T6])]

def maybe[T1, T2, T3, T4, T5](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4], v5: W[T5])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4], Op[T5])]

def maybe[T1, T2, T3, T4](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3], Op[T4])]

def maybe[T1, T2, T3](v1: W[T1], v2: W[T2], v3: W[T3])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2], Op[T3])]

def maybe[T1, T2](v1: W[T1], v2: W[T2])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1], Op[T2])]

def maybe[T1](v1: W[T1])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Op[T1])]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def one(implicit conn: Connection): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

def recreateDbFrom(tx: Transaction, identifier: String = "", protocol: String = "mem"): Connection

def results(conn: Connection, model: Model, query: Query): List[List[AnyRef]]

def save(conn: Connection, model: Model): Tx

def since(d: Date): Molecule15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

def since_[M <: Molecule](thisMolecule: M, date: Date): M

def some(implicit conn: Connection): Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def update(implicit conn: Connection): Tx

def update(conn: Connection, model: Model): Tx

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit