Type Members

1.  final class A extends AnyRef

   Array helpers

2.  case class ActorPingException(msg: String, e: Throwable) extends RuntimeException with Product with Serializable

   Exception thrown if a ping can't be scheduled.

3.  abstract class AnyVar[T, MyType <: AnyVar[T, MyType]] extends AnyVarTrait[T, MyType]
4.  trait AnyVarTrait[T, MyType <: AnyVarTrait[T, MyType]] extends PSettableValueHolder[T] with HasCalcDefaultValue[T]

   Abstract a request or a session scoped variable.

5.  final case class AppendDelta[T](item: T) extends DeltaInfo[T] with Product with Serializable
6.  final case class AppendKidsSubNode() extends SubNode with WithKids with Product with Serializable
7.  final case class AttrAppendSubNode(attr: String) extends SubNode with AttributeRule with Product with Serializable
8.  trait AttrHelper[+Holder[X]] extends AnyRef

   A common function-like interface for accessing information about attributes, based on the two core findAttr and convert methods.

   A common function-like interface for accessing information about attributes, based on the two core findAttr and convert methods.

   Extenders can be fairly flexible. The value of an attribute is specified by the extender as type Info. Possibly-missing attributes are returned in type Holder, which should be parametrizable. For example, you could create an AttrHelper that deals in String attribute values (type Info = String) and returns Options in cases where the attribute may not be found.

   Note that you can invoke an AttrHelper with conversion functions to turn an Info into an arbitrary type.

   A sample implementation:

   case class HtmlAttributes(in: Elem) extends AttrHelper[Box] {
     type Info = String
   
     def findAttr(key: String): Option[Info] = {
       in.attribute(key).map(_.text)
     }
   
     def findAttr(prefix: String, key: String): Option[Info] = {
       in.attribute(prefix, key).map(_.text)
     }
   
     def convert[T](in: Option[T]): Box[T] = Box(in)
   }

   The helper above takes a scala Elem and provides a series of ways to access the values of its elements. For example:

   val attributes = HtmlAttributes(elem)
   
   attributes("class") // class attribute as String, Empty if absent
   attributes("lift", "bind") // as above with lift:bind attribute
   attributes("class", "nothing") // class attribute, "nothing" if absent
   attributes("lift", "bind", "nothing") // as above with lift:bind attribute
   attributes("class", _.split(" ")) // class attribute as array, Empty if absent
   attributes("lift", "bind", _.split(" ")) // as above with lift:bind attribute
   attributes("class", _.split(" "), Array()) // class attribute as array, Array() if absent
   attributes("lift", "bind", _.split(" "), Array()) // as above with lift:bind attribute

9.  final case class AttrRemoveSubNode(attr: String) extends SubNode with AttributeRule with Product with Serializable
10.  final case class AttrSelector(name: String, value: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable
11.  final case class AttrSubNode(attr: String) extends SubNode with AttributeRule with Product with Serializable
12.  sealed trait AttributeRule extends AnyRef
13.  trait AutoResourceManager[ResourceType] extends AnyRef

    A trait that defines an Automatic Resource Manager.

    A trait that defines an Automatic Resource Manager. The ARM allocates a resource (connection to a DB, etc.) when the exec method is invoked and releases the resource before the exec method terminates

    ResourceType

    the type of resource allocated

14.  trait AvoidTypeErasureIssues1 extends AnyRef

    Generics on the JVM have an issues with Type Erasure.

    Generics on the JVM have an issues with Type Erasure. Basically, Generic types (e.g., Function1[String, Int] and Function1[Double, Bool]) look like the same type to the JVM so that methods cannot be overloaded with generic types. This "marker" trait is used as a work-around to the issue. The marker is implicitly passed as a parameter to some overloaded methods. If you see this as an implicit parameter to an overloaded method, just ignore it.

15.  trait BaseField extends SettableField with FieldContainer
16.  trait BasicTypesHelpers extends AnyRef

    This trait adds functionality to Scala standard types

17.  trait Bindable extends AnyRef

    This trait is used to identify an object that is representable as a NodeSeq.

18.  final case class BoxNodeSeqFuncIterableConst(it: Box[(NodeSeq) ⇒ NodeSeq]) extends IterableConst with Product with Serializable

    The implementation for a Box[NodeSeq => Node] Iterable Const

19.  trait CanBind[-T] extends AnyRef

    Annotations

    @implicitNotFound( ... )

20.  trait CanResolveAsync[ResolvableType, ResolvedType] extends AnyRef

    Represents a unifying class that can resolve an asynchronous container.

    Represents a unifying class that can resolve an asynchronous container. For example, a Future[String] can be resolved by a CanResolveAsync[Future[String], String].

    Provides one method, resolveAsync, that takes the async container and a function to run when the container resolves.

21.  trait Cell[T] extends Dependent

    A wiring Cell.

    A wiring Cell. A Cell can be a ValueCell which holds a value which can be set (and thus update the dependencies), a FuncCell (a cell that is a function that depends on other cells), or a DynamicCell which has a value that updates each time the cell is accessed.

22.  trait ClassHelpers extends AnyRef

    ClassHelpers provide several functions to instantiate a Class object given the class name and one or more package names

23.  final case class ClassSelector(clss: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable
24.  class ClearClearable extends CssBindImpl

    This CssBind will clear all nodes marked with the class clearable.

    This CssBind will clear all nodes marked with the class clearable. Designers can mark extra nodes in markup with class="clearable" and this Bind will make them go away

25.  trait CombParserHelpers extends AnyRef

    The CombParserHelpers trait provides parser combinators helpers.

26.  class ConcurrentLock extends ReentrantReadWriteLock
27.  trait ConfirmField extends BaseField

    A base field that also has a confirm method

28.  trait ConnectionIdentifier extends AnyRef
29.  trait ControlHelpers extends ClassHelpers with Tryo

    Control helpers provide alternate ways to catch exceptions and ignore them as necessary

30.  trait ConvertableToDate extends AnyRef
31.  final class Css extends AnyRef

    The bridge from Java to Lift's CSS Selector Transforms

32.  trait CssBind extends CssSel
33.  type CssBindFunc = CssSel
34.  abstract class CssBindImpl extends CssBind

    An abstract implementation of CssBind.

    An abstract implementation of CssBind. You can instantiate this class and create a custom calculate method

35.  trait CssBindImplicits extends AnyRef
36.  final class CssJBridge extends CssBindImplicits

    Bridge from Java-land to Scala

37.  trait CssSel extends (NodeSeq) ⇒ NodeSeq

    This trait is both a NodeSeq => NodeSeq and has the ability to chain CssSel instances so that they can be applied en masse to incoming NodeSeq and do the transformation.

38.  sealed trait CssSelector extends AnyRef
39.  case class CssUrlPrefixer(prefix: String) extends Parsers with Product with Serializable

    Utility for prefixing root-relative urls in CSS with a given prefix.

    Utility for prefixing root-relative urls in CSS with a given prefix. Typically used to prefix root-relative CSS urls with the application context path.

    After creating the prefixer with the prefix you want to apply to root-relative paths, call fixCss with a CSS string to return a fixed CSS string.

40.  class Currency extends AnyRef

    A simple fixed-point currency representation

41.  class CurrencyMismatchException extends Exception

    This exception is thrown if an operation is attempted on two currency values where currency symbols do not match.

42.  abstract class CurrencyZone extends AnyRef
43.  trait DateTimeConverter extends AnyRef

    Implement this trait to specify a set of rules to parse and format dates

44.  sealed trait DeltaInfo[T] extends AnyRef

    Provide information about the deltas between two lists

45.  trait Dependent extends AnyRef

    Something that depends on the values of other cells

46.  trait DollarCurrency extends TwoFractionDigits
47.  final case class DynamicCell[T](f: () ⇒ T) extends Cell[T] with Product with Serializable

    A cell that changes value on each access.

    A cell that changes value on each access. This kind of cell could be used to access an external resource. Warning the function may be accessed many times during a single wiring recalculation, so it's best to use this as a front to a value that's memoized for some duration.

48.  trait DynoVar[T] extends AnyRef
49.  final case class ElemSelector(elem: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable
50.  final case class EnclosedSelector(selector: CssSelector, kid: CssSelector) extends CssSelector with Product with Serializable
51.  abstract class EnumWithDescription extends AnyRef
52.  case class False(msgs: List[String]) extends MonadicCondition with Product with Serializable
53.  class FatLazy[T] extends AnyRef

    A class that does lazy evaluation

54.  trait FieldContainer extends AnyRef
55.  trait FieldConverter extends AnyRef

    Convert the field into other representations

56.  case class FieldError(field: FieldIdentifier, msg: NodeSeq) extends Product with Serializable

    Associate a FieldIdentifier with a NodeSeq

57.  trait FieldIdentifier extends AnyRef

    Defines the association of this reference with a markup tag ID

58.  case class FormBuilderLocator[T](func: (T, (T) ⇒ Unit) ⇒ NodeSeq)(implicit manifest: Manifest[T]) extends Product with Serializable
59.  final case class FuncCell1[A, Z](a: Cell[A], f: (A) ⇒ Z) extends Cell[Z] with Product with Serializable
60.  final case class FuncCell2[A, B, Z](a: Cell[A], b: Cell[B], f: (A, B) ⇒ Z) extends Cell[Z] with Product with Serializable
61.  final case class FuncCell3[A, B, C, Z](a: Cell[A], b: Cell[B], c: Cell[C], f: (A, B, C) ⇒ Z) extends Cell[Z] with Product with Serializable
62.  final case class FuncCell4[A, B, C, D, Z](a: Cell[A], b: Cell[B], c: Cell[C], d: Cell[D], f: (A, B, C, D) ⇒ Z) extends Cell[Z] with Product with Serializable
63.  final case class FuncCell5[A, B, C, D, E, Z](a: Cell[A], b: Cell[B], c: Cell[C], d: Cell[D], e: Cell[E], f: (A, B, C, D, E) ⇒ Z) extends Cell[Z] with Product with Serializable
64.  trait HasCalcDefaultValue[T] extends AnyRef
65.  trait HasParams extends AnyRef
66.  trait Html5Parser extends AnyRef

    A utility that supports parsing of HTML5 file.

    A utility that supports parsing of HTML5 file. The Parser hooks up nu.validator.htmlparser to

67.  trait Html5Writer extends AnyRef
68.  trait HtmlHelpers extends CssBindImplicits
69.  trait HttpHelpers extends AnyRef
70.  final case class IdSelector(id: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable
71.  class InMemoryCache extends TemplateCache[(Locale, List[String]), NodeSeq]

    Caches templates in a LRU map

72.  trait Injector extends AnyRef

    A trait that does basic dependency injection.

73.  final case class InsertAfterDelta[T](item: T, after: T) extends DeltaInfo[T] with Product with Serializable
74.  final case class InsertAtStartDelta[T](item: T) extends DeltaInfo[T] with Product with Serializable
75.  trait IoHelpers extends AnyRef
76.  trait IterableConst extends AnyRef

    A trait that has some helpful implicit conversions from Iterable[NodeSeq], Seq[String], Box[String], and Option[String]

77.  sealed trait IterableFunc extends (NodeSeq) ⇒ Seq[NodeSeq]
78.  trait JodaHelpers extends AnyRef
79.  case class JsonCmd(command: String, target: String, params: Any, all: Map[String, Any]) extends Product with Serializable

    Impersonates a JSON command

80.  class KeyedCache[K, T] extends AnyRef

    A simple Read-through cache.

    A simple Read-through cache.

    An example of using it with a ProtoUser subclass:

    object UserCache extends KeyedCache[Long, User](100, Full(0.75f), (id: Long) => User.find(By(User.id, id)))

81.  final case class KidsSubNode() extends SubNode with WithKids with Product with Serializable
82.  class LRU[KeyType, ValueType] extends LRUMap[KeyType, ValueType]

    LRU Cache wrapping org.apache.commons.collections.map.LRUMap

83.  class LZ[T] extends AnyRef

    LZ encapsulates a lazy value.

84.  class LiftFlowOfControlException extends RuntimeException

    The superclass for all Lift flow of control exceptions

85.  trait LiftValue[T] extends PSettableValueHolder[T]

    Kinda like a JavaBean property.

    Kinda like a JavaBean property. It's something that can be set and retrieved

86.  trait ListHelpers extends AnyRef

    The ListHelpers trait provides useful functions which can be applied to Lists.

87.  trait LoanWrapper extends CommonLoanWrapper

    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.

88.  trait LowPriorityCanResolveAsyncImplicits extends AnyRef
89.  trait Mailer extends SimpleInjector

    This trait implmenets the mail sending.

    This trait implmenets the mail sending. You can create subclasses of this class/trait and implement your own mailer functionality

90.  trait Maker[T] extends AnyRef

    In addition to an Injector, you can have a Maker which will make a given type.

    In addition to an Injector, you can have a Maker which will make a given type. The important thing about a Maker is that it's intended to be used as part of a factory that can vend an instance without the vaguaries of whether the given class has registered a with the injector.

91.  class MakerJ extends AnyRef

    Maker is part of Lift's dependency injection mechanism.

    Maker is part of Lift's dependency injection mechanism. This method is a bridge to the Scala methods.

92.  class MakerStack[T] extends StackableMaker[T]

    An implementation where you can define the stack of makers.

93.  trait MemoizeVar[K, V] extends AnyRef
94.  trait MonadicCondition extends AnyRef

    A MonadicCondition allows building boolean expressions of the form (a(0) && a(1) && ..

    A MonadicCondition allows building boolean expressions of the form (a(0) && a(1) && .. && a(n)), where a(k) is a boolean expression, and collecting the computation failures to a list of messages.

    Example:
    
      val isTooYoung = true;
      val isTooBad = false;
      val isTooStupid = true;
    
      val exp = (!isTooYoung ~ "too young") &&
                (!isTooBad ~ "too bad") &&
                (!isTooStupid ~ "too stupid")
    
      println(exp match {
        case False(msgs) => msgs mkString("Test failed because it is '", "' and '", "'.")
        case _ => "success"
      })
    

95.  final case class NameSelector(name: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable
96.  class NamedPF[-A, +B] extends NamedPartialFunction[A, B]

    This class is the base implementation of the NamedPartialFunction trait.

97.  trait NamedPartialFunction[-A, +B] extends PartialFunction[A, B]

    This trait is used to represent a PartialFunction with additional associated metadata, a name that allows the NamedPartialFunction to be looked up dynamically.

98.  final case class NodeSeqFuncIterableConst(it: Iterable[(NodeSeq) ⇒ NodeSeq]) extends IterableConst with Product with Serializable

    The implementation for a NodeSeq => NodeSeq Iterable Const

99.  final case class NodeSeqIterableConst(it: Iterable[NodeSeq]) extends IterableConst with Product with Serializable

    The implementation for a NodeSeq Iterable Const

100.  abstract class NonCleanAnyVar[T] extends AnyVar[T, NonCleanAnyVar[T]]
101.  final case class OptionNodeSeqFuncIterableConst(it: Option[(NodeSeq) ⇒ NodeSeq]) extends IterableConst with Product with Serializable

     The implementation for a Option[NodeSeq => Node] Iterable Const

102.  case class PCData(_data: String) extends Atom[String] with Product with Serializable
103.  trait PCDataMarkupParser[PCM <: MarkupParser with MarkupHandler] extends MarkupParser

     Extends the Markup Parser to do the right thing (tm) with PCData blocks

104.  class PCDataXmlParser extends ConstructingHandler with PCDataMarkupParser[PCDataXmlParser] with ExternalSources
105.  trait PSettableValueHolder[T] extends PValueHolder[T] with SettableValueHolder
106.  trait PValueHolder[T] extends ValueHolder
107.  final case class PrependKidsSubNode() extends SubNode with WithKids with Product with Serializable
108.  class REDoer[T] extends (T, String) ⇒ Box[T]
109.  class REMatcher extends AnyRef

     This class adds higher-order functions and lazy evaluation for pattern matching on top of the standard Java regular expressions library.

110.  trait ReadableField extends FieldIdentifier with ValueHolder with Bindable

     A field that can be displayed but not edited

111.  final case class RemoveDelta[T](item: T) extends DeltaInfo[T] with Product with Serializable

     The new list does not contain the item.

     The new list does not contain the item. Remove it from the list

112.  class ResponseInfoHolder extends AnyRef

     Holds information about a response

113.  class RestoringWeakReference[T <: AnyRef] extends AnyRef

     RestoringWeakReference contains a scala.ref.WeakReference that, after it has been nulled out, uses a restorer function to restore the value.

     RestoringWeakReference contains a scala.ref.WeakReference that, after it has been nulled out, uses a restorer function to restore the value. This can be used for data that can afford to be evicted by the garbage collector, but will be needed later. One good example is Lift form callbacks, which may need the value of an object, but where you don't necessarily want to be retaining the object indefinitely while someone is on a page in the face of GC contention.

     You can use RestoringWeakReference in a couple of basic ways:

     val ref = RestoringWeakReference(() => User.find(id))

     In this situation, the RestoringWeakReference will immediately call the passed function to provide the starting value for the reference, and then the same function will be used if the reference is evicted.

     val ref = RestoringWeakReference(starter, () => User.find(id))

     Here, starter is an Option[User] and User.find returns an Option[User]. The first parameter will be used to initialize the weak reference, while the function will be used to restore the value if the reference is evicted.

     val baseRef = new WeakReference(starter)
     val ref = new RestoringWeakReference(baseRef, () => User.find(id))

     If you already have a WeakReference instance, you can instantiate RestoringWeakReference directly and pass that reference as the starting value, as well.

     In all these cases, you use ref.value to get a hold of the value. That function will return the value if it is available, and, if not, it will restore the WeakReference and then return the value.

114.  trait SafeSeqParser extends Parsers
115.  sealed trait Schedule extends Loggable

     The Schedule object schedules an actor to be ping-ed with a given message after a specified delay.

     The Schedule object schedules an actor to be ping-ed with a given message after a specified delay. If you need recurrent scheduled pings you will need to reschedule.

     The schedule methods return a ScheduledFuture object which can be cancelled if necessary

116.  class ScheduleJBridge extends AnyRef
117.  trait SecurityHelpers extends AnyRef

     The SecurityHelpers trait provides functions to:

     The SecurityHelpers trait provides functions to:

     • generate random numbers
     • generate keys
     • encrypt/decrypt keys
     • create SHA, SHA-256, MD5 hashes (can be hex encoded)
118.  final case class SelectThisNode(kids: Boolean) extends SubNode with Product with Serializable
119.  final case class SeqBindableIterableConst(it: Iterable[Bindable]) extends IterableConst with Product with Serializable

     Sequence of Bindable iterable const

120.  final case class SeqCell[T](cells: Cell[T]*) extends Cell[Seq[T]] with Product with Serializable

     A collection of Cells og a given type

121.  final case class SeqStringIterableConst(it: Iterable[String]) extends IterableConst with Product with Serializable

     Sequence of String iterable const

122.  trait Settable extends ValueHolder

     A value that can be set

123.  trait SettableField extends ReadableField with SettableValueHolder

     A field that can be set

124.  trait SettableValueHolder extends Settable
125.  trait SimpleInjector extends Injector

     An implementation of Injector that has an implementation

126.  class SoftReferenceCache[K, V] extends AnyRef

     A Map that holds the values as SoftReference-s.

     A Map that holds the values as SoftReference-s. It also applies a LRU policy for the cache entries.

127.  class SoftValue[K, V] extends SoftReference[V]
128.  trait SourceFieldInfo extends AnyRef

     Value and metadata for a field

129.  case class SourceFieldInfoRep[A](value: A, metaData: SourceFieldMetadata { type ST = A }) extends SourceFieldInfo with Product with Serializable

     An inplementation of SourceFieldInfo

     An inplementation of SourceFieldInfo

     A

     the type

     value

     the value

     metaData

     the metadata

130.  trait SourceFieldMetadata extends AnyRef

     Metadata about a specific field

131.  case class SourceFieldMetadataRep[A](name: String, manifest: scala.reflect.api.JavaUniverse.TypeTag[A], converter: FieldConverter { type T = A }) extends SourceFieldMetadata with Product with Serializable
132.  trait SourceInfo extends AnyRef

     A trait that allows an object to tell you about itself rather than using reflection

133.  trait StackableMaker[T] extends Maker[T]

     A StackableMaker allows DynamicVar functionality by supply a Maker or function that will vend an instance during any sub-call on the stack and then restore the implementation.

     A StackableMaker allows DynamicVar functionality by supply a Maker or function that will vend an instance during any sub-call on the stack and then restore the implementation. This is value for testing.

134.  final case class StarSelector(subNodes: Box[SubNode], singleDepth: Boolean) extends CssSelector with Product with Serializable
135.  trait StringHelpers extends AnyRef

     Utility methods for manipulating strings.

136.  trait StringPromotable extends AnyRef

     This trait marks something that can be promoted into a String.

     This trait marks something that can be promoted into a String. The companion object has helpful conversions from Int, Symbol, Long, and Boolean

137.  trait StringValidators extends AnyRef
138.  sealed trait SubNode extends AnyRef
139.  final class SuperListString extends AnyRef

     A class that allows chaining "foo" / "bar" / "baz"

140.  final case class SuperString(what: String) extends Product with Serializable

     The SuperString class adds functionalities to the String class

141.  final case class SurroundKids() extends SubNode with WithKids with Product with Serializable
142.  trait TemplateCache[K, V] extends AnyRef
143.  class ThreadGlobal[T] extends AnyRef

     This is a decorator for a ThreadLocal variable that provides convenience methods to transform the variable to a Box and execute functions in a "scope" wherein the variable may hold a different value.

144.  class ThreadLazy[TheType] extends LoanWrapper

     A thread-local lazy value that provides a means to evaluate a function in a lazily-evaluated scope.

145.  trait TimeHelpers extends AnyRef

     The TimeHelpers trait provide functions to create TimeSpans (an object representing duration in milliseconds), to manage date formats or general utility functions (get the date for today, get year/month/day number,...)

146.  trait ToJsCmd extends AnyRef

     TODO: Is this something that can be converted to a JavaScript Command

147.  trait TwoFractionDigits extends AnyRef
148.  final class ValueCell[A] extends Cell[A] with LiftValue[A]

     A ValueCell holds a value that can be mutated.

149.  trait ValueHolder extends AnyRef
150.  trait ValueWithDescription extends AnyRef
151.  trait Vendor[T] extends Maker[T] with () ⇒ T

     A Vendor is a Maker that also guarantees that it will return a value

152.  final class VendorJ extends AnyRef

     The bridge from Java to Lift's Vendor stuff

153.  class VendorJBridge extends AnyRef

     A bridge from Java to Scala

154.  sealed trait WithKids extends AnyRef
155.  class BCrypt extends AnyRef

     This class is a passthrough to org.mindrot.jbcrypt.BCrypt, provided for backwards compatibility as we kept a copy in the Lift codebase before it was available for package dependencies.

     This class is a passthrough to org.mindrot.jbcrypt.BCrypt, provided for backwards compatibility as we kept a copy in the Lift codebase before it was available for package dependencies. Prefer using org.mindrot.jbcrypt.BCrypt.

     Annotations

     @Deprecated

     Deprecated