Registry

abstract def registrantsName: String

abstract def registryName: String

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Registry[T], B)

final def ==(arg0: Any): Boolean

final def _register(key: Symbol, obj: T): obj.type

final def _unregister(key: Symbol): Unit

def apply(name: Symbol): Option[T]

def as[U <: Registrable[T]](id: Symbol): U

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contains(key: Symbol): Boolean

def containsValue(value: T): Boolean

def createLoggerName: String

def ensuring(cond: (Registry[T]) ⇒ Boolean, msg: ⇒ Any): Registry[T]

def ensuring(cond: (Registry[T]) ⇒ Boolean): Registry[T]

def ensuring(cond: Boolean, msg: ⇒ Any): Registry[T]

def ensuring(cond: Boolean): Registry[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(name: Symbol): Boolean

def finalize(): Unit

def find(ids: Seq[Symbol]): Seq[T]

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def getRegistrant(name: Symbol): Option[T]

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isRegistered(name: Symbol): Boolean

def keys: Seq[Symbol]

def level: Level

lazy val log: Logger

def loggerName: String

def lookup(key: Symbol): Option[T]

def lookupOrElse(key: Symbol, value: T): Option[T]

def map[W](f: ((Symbol, T)) ⇒ (Symbol, W)): Map[Symbol, W]

def mkThrowable(msg: String, cause: Option[Throwable] = None): ThrowableWithComponent

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

def notImplemented(what: String): Nothing

final def notify(): Unit

final def notifyAll(): Unit

def pick: T

def pick(index: Int): Symbol

val rand: Random

def register(thing: T): Unit

def select(f: ((Symbol, T)) ⇒ Boolean): Iterable[T]

def size: Int

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

def toString(): String

def toss(msg: ⇒ String, cause: Option[Throwable] = None): Nothing

Identity Aware Exception Toss This function makes it easier to throw (toss) an exception that adds a message to it and also identifies the tosser that threw it.

def unregister(thing: T): Unit

def values: Seq[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (Registry[T], B)