common

Type Members

1. sealed abstract class Box[+A] extends Product with Serializable

   

   The Box class is a container which is able to declare if it is Full (containing a single non-null value) or EmptyBox.

   The Box class is a container which is able to declare if it is Full (containing a single non-null value) or EmptyBox. An EmptyBox, or empty, can be the Empty singleton, Failure or ParamFailure. Failure and ParamFailure contain information about why the Box is empty including exception information, chained Failures and a String. It serves a similar purpose to the Option class from Scala standard library but adds several features:

   • you can transform it to a Failure object if it is Empty (with the ?~ method)
   • you can chain failure messages on Failure Boxes
   • you "run" a function on your Box, with a default value: Full(1).run("zero") { (x: String, y: Int) => y.toString }
   • you can "pass" a Box to a function for side effects: Full(1) $ { x: Box[Int] => println(x openOr 0) }

2. class BoxJBridge extends AnyRef

   

   The bridge from Java to Scala Box

3. sealed trait BoxOrRaw[T] extends AnyRef

   

   Sometimes it's convenient to access either a Box[T] or a T.

   Sometimes it's convenient to access either a Box[T] or a T. If you specify BoxOrRaw[T], the either a T or a Box[T] can be passed and the "right thing" will happen

4. sealed trait BoxTrait extends AnyRef

   

   The Box companion object provides methods to create a Box from:

   The Box companion object provides methods to create a Box from:

   • an Option
   • a List
   • any AnyRef object

   It also provides implicit methods to transform Option to Box, Box to Iterable, and Box to Option

5. trait Boxable[T] extends AnyRef

   

   A trait that a class can mix into itself to convert itself into a Box

6. final case class BoxedBoxOrRaw[T](box: Box[T]) extends BoxOrRaw[T] with Product with Serializable

   

   The Boxed up BoxOrRaw

7. trait CommonLoanWrapper extends AnyRef

   

   This trait defines the principle contract for function objects that wrap the processing of HTTP requests by Lift while utilizing the preestablished request-local scope.

8. final case class ConstNodeSeqFunc(ns: NodeSeq) extends NodeSeqFunc with Product with Serializable

   

   The case class that holds the NodeSeq constant.

9. final case class ConstStringFunc(str: String) extends StringFunc with Product with Serializable

   

   The case class that holds the String constant.

10. sealed abstract class EmptyBox extends Box[Nothing] with Serializable

    

    The EmptyBox is a Box containing no value.

11. sealed trait ExcludeThisType[A, B] extends AnyRef

    

    Encoding for "A is not a subtype of B"

12. sealed case class Failure(msg: String, exception: Box[Throwable], chain: Box[Failure]) extends EmptyBox with Product with Serializable

    

    A Failure is an EmptyBox with an additional failure message explaining the reason for its being empty.

    A Failure is an EmptyBox with an additional failure message explaining the reason for its being empty. It can also optionally provide an exception or a chain of causes represented as a list of other Failure objects

13. trait ForwardableActor[From, To] extends AnyRef

    

14. final case class Full[+A](value: A) extends Box[A] with Product with Serializable

    

    Full is a Box containing a value.

15. final class Func extends AnyRef

    

16. trait Func0[Z] extends AnyRef

    

17. trait Func1[A, Z] extends AnyRef

    

18. trait Func2[A, B, Z] extends AnyRef

    

19. trait Func3[A, B, C, Z] extends AnyRef

    

20. trait Func4[A, B, C, D, Z] extends AnyRef

    

21. class FuncJBridge extends AnyRef

    

    Bridge from Java functions to Scala functions

22. trait GenericActor[+R] extends TypedActor[Any, R]

    

    Generic Actor interface.

    Generic Actor interface. Can receive any type of message. Can return (via !! and !?) messages of type R.

23. class LRUMap[K, V] extends LinkedListElem[K, V]

    

    Implements an LRU Hashmap

24. trait LazyLoggable extends AnyRef

    

    Mixin with a nested lazy Logger

    Mixin with a nested lazy Logger

    Useful for mixin to objects that are created before Lift has booted (and thus Logging is not yet configured)

25. case class ListOfBoxes[T](theListOfBoxes: List[Box[T]]) extends Product with Serializable

    

    Helper class to provide an easy way for converting Lists of Boxes[T] into a Box of List[T].

26. trait Loggable extends AnyRef

    

    Mixin with a nested Logger

27. trait Logger extends AnyRef

    

    Logger is a thin wrapper on top of an SLF4J Logger

    Logger is a thin wrapper on top of an SLF4J Logger

    The main purpose is to utilize Scala features for logging

    Note that the dynamic type of "this" is used when this trait is mixed in.

    This may not always be what you want. If you need the static type, you have to declare your own Logger:

    class MyClass { val logger = Logger(classOf[MyClass]) }

28. sealed trait NodeSeqFunc extends AnyRef

    

    Sometimes you want a function that returns a NodeSeq as a parameter, but many times, you'll just want to pass a NodeSeq constant.

    Sometimes you want a function that returns a NodeSeq as a parameter, but many times, you'll just want to pass a NodeSeq constant. In those cases, this trait and it's implicit conversions come in really handy. Basically, a NodeSeq constant or a NodeSeq function can be passed and either will be implicitly converted into a NodeSeqFunc.

29. final class ParamFailure[T] extends Failure with Serializable

    

    A ParamFailure is a Failure with an additional typesafe parameter that can allow an application to store other information related to the failure.

30. final case class RawBoxOrRaw[T](raw: T) extends BoxOrRaw[T] with Product with Serializable

    

    The raw version of BoxOrRaw

31. final case class RealNodeSeqFunc(func: () ⇒ NodeSeq) extends NodeSeqFunc with Product with Serializable

    

    The case class that holds a NodeSeq function.

32. final case class RealStringFunc(func: () ⇒ String) extends StringFunc with Product with Serializable

    

    The case class that holds a String function.

33. trait SimpleActor[-T] extends AnyRef

    

    The simple definition of an actor.

    The simple definition of an actor. Something that can receive a message of type T.

34. final case class SimpleList[T](underlying: List[T]) extends List[T] with Product with Serializable

    

    An immutable singly linked list that uses the Scala List class as backing store, but is Java-friendly.

35. final case class SimpleVector[T](underlying: Vector[T]) extends List[T] with Product with Serializable

    

    An immutable singly linked list that uses the Scala List class as backing store, but is Java-friendly.

36. trait SimplestActor extends SimpleActor[Any]

    

    An Actor that can receive a message of any type

37. trait SimplestGenericActor extends GenericActor[Any]

    

    Generic Actor interface.

    Generic Actor interface. Can receive any type of message. Can return (via !! and !?) messages of any type.

38. sealed trait StringFunc extends AnyRef

    

    Sometimes you want a function that returns a String as a parameter, but many times, you'll just want to pass a String constant.

    Sometimes you want a function that returns a String as a parameter, but many times, you'll just want to pass a String constant. In those cases, this trait and it's implicit conversions come in really handy. Basically, a String constant or a String function can be passed and either will be implicitly converted into a StringFunc.

39. sealed trait StringOrNodeSeq extends AnyRef

    

    A helpful trait that will accept either a String or a NodeSeq via an implicit conversion.

    A helpful trait that will accept either a String or a NodeSeq via an implicit conversion. So, all you need to do is put in a String or a NodeSeq and the right thing will happen.

40. trait TypedActor[-T, +R] extends SimpleActor[T]

    

    An Actor that can receive messsages of type T and return responses of type R.

41. class WrappedLogger extends Logger