Packages

package util

The util package object

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. util
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final class A extends AnyRef
  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. class BCrypt extends AnyRef
  16. trait BaseField extends SettableField with FieldContainer
  17. trait BasicTypesHelpers extends AnyRef

    This trait adds functionality to Scala standard types

  18. trait Bindable extends AnyRef

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

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

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

  20. trait CanBind [-T] extends AnyRef
    Annotations
    @implicitNotFound( ... )
  21. 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.

  22. 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.

  23. trait ClassHelpers extends AnyRef

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

  24. final case class ClassSelector (clss: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable
  25. 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

  26. trait CombParserHelpers extends AnyRef

    The CombParserHelpers trait provides parser combinators helpers.

  27. class ConcurrentLock extends ReentrantReadWriteLock
  28. trait ConfirmField extends BaseField

    A base field that also has a confirm method

  29. trait ConnectionIdentifier extends AnyRef
  30. trait ControlHelpers extends ClassHelpers with Tryo

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

  31. trait ConvertableToDate extends AnyRef
  32. final class Css extends AnyRef
  33. trait CssBind extends CssSel
  34. type CssBindFunc = CssSel
  35. 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

  36. trait CssBindImplicits extends AnyRef
  37. final class CssJBridge extends CssBindImplicits

    Bridge from Java-land to Scala

  38. 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.

  39. sealed trait CssSelector extends AnyRef
  40. 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.

  41. class Currency extends AnyRef

    A simple fixed-point currency representation

  42. class CurrencyMismatchException extends Exception

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

  43. abstract class CurrencyZone extends AnyRef
  44. trait DateTimeConverter extends AnyRef

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

  45. sealed trait DeltaInfo [T] extends AnyRef

    Provide information about the deltas between two lists

  46. trait Dependent extends AnyRef

    Something that depends on the values of other cells

  47. trait DollarCurrency extends TwoFractionDigits
  48. 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.

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

    A class that does lazy evaluation

  55. trait FieldContainer extends AnyRef
  56. trait FieldConverter extends AnyRef

    Convert the field into other representations

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

    Associate a FieldIdentifier with a NodeSeq

  58. trait FieldIdentifier extends AnyRef

    Defines the association of this reference with a markup tag ID

  59. case class FormBuilderLocator [T](func: (T, (T) ⇒ Unit) ⇒ NodeSeq)(implicit manifest: Manifest[T]) extends Product with Serializable
  60. final case class FuncCell1 [A, Z](a: Cell[A], f: (A) ⇒ Z) extends Cell[Z] with Product with Serializable
  61. final case class FuncCell2 [A, B, Z](a: Cell[A], b: Cell[B], f: (A, B) ⇒ Z) extends Cell[Z] with Product with Serializable
  62. 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
  63. 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
  64. 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
  65. trait HasCalcDefaultValue [T] extends AnyRef
  66. trait HasParams extends AnyRef
  67. 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

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

    Caches templates in a LRU map

  73. trait Injector extends AnyRef

    A trait that does basic dependency injection.

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

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

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

    Impersonates a JSON command

  81. 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)))

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

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

  84. class LZ [T] extends AnyRef

    LZ encapsulates a lazy value.

  85. class LiftFlowOfControlException extends RuntimeException

    The superclass for all Lift flow of control exceptions

  86. 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

  87. trait ListHelpers extends AnyRef

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

  88. 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.

  89. trait LowPriorityCanResolveAsyncImplicits extends AnyRef
  90. 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

  91. 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.

  92. class MakerJ extends AnyRef
  93. class MakerStack [T] extends StackableMaker[T]

    An implementation where you can define the stack of makers.

  94. trait MemoizeVar [K, V] extends AnyRef
  95. 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"
      })
    

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

    This class is the base implementation of the NamedPartialFunction trait.

  98. 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.

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

    The implementation for a NodeSeq => NodeSeq Iterable Const

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

    The implementation for a NodeSeq Iterable Const

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

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

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

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

  105. class PCDataXmlParser extends ConstructingHandler with PCDataMarkupParser[PCDataXmlParser] with ExternalSources
  106. trait PSettableValueHolder [T] extends PValueHolder[T] with SettableValueHolder
  107. trait PValueHolder [T] extends ValueHolder
  108. final case class PrependKidsSubNode () extends SubNode with WithKids with Product with Serializable
  109. class REDoer [T] extends (T, String) ⇒ Box[T]
  110. 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.

  111. trait ReadableField extends FieldIdentifier with ValueHolder with Bindable

    A field that can be displayed but not edited

  112. 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

  113. class ResponseInfoHolder extends AnyRef

    Holds information about a response

  114. 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.

  115. trait SafeSeqParser extends Parsers
  116. 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

  117. class ScheduleJBridge extends AnyRef
  118. 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)
  119. final case class SelectThisNode (kids: Boolean) extends SubNode with Product with Serializable
  120. final case class SeqBindableIterableConst (it: Iterable[Bindable]) extends IterableConst with Product with Serializable

    Sequence of Bindable iterable const

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

    A collection of Cells og a given type

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

    Sequence of String iterable const

  123. trait Settable extends ValueHolder

    A value that can be set

  124. trait SettableField extends ReadableField with SettableValueHolder

    A field that can be set

  125. trait SettableValueHolder extends Settable
  126. trait SimpleInjector extends Injector

    An implementation of Injector that has an implementation

  127. 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.

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

    Value and metadata for a field

  130. 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

  131. trait SourceFieldMetadata extends AnyRef

    Metadata about a specific field

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

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

  134. 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.

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

    Utility methods for manipulating strings.

  137. 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

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

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

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

    The SuperString class adds functionalities to the String class

  142. final case class SurroundKids () extends SubNode with WithKids with Product with Serializable
  143. trait TemplateCache [K, V] extends AnyRef
  144. 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.

  145. class ThreadLazy [TheType] extends LoanWrapper

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

  146. 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,...)

  147. trait ToJsCmd extends AnyRef

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

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

    A ValueCell holds a value that can be mutated.

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

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

  153. final class VendorJ extends AnyRef
  154. class VendorJBridge extends AnyRef

    A bridge from Java to Scala

  155. sealed trait WithKids extends AnyRef

Value Members

  1. def itConst[T](ic: T)(implicit f: (T) ⇒ IterableConst): IterableConst

    Promote to an IterableConst when implicits won't do it for you

    Promote to an IterableConst when implicits won't do it for you

    T

    the type of the parameter

    ic

    the thing that can be promoted to an IterableConst

    f

    the implicit function that takes T and makes it an IterableConst

    returns

    an IterableConst

  2. def nsFunc(f: (NodeSeq) ⇒ NodeSeq): (NodeSeq) ⇒ NodeSeq

    Wrap a function and make sure it's a NodeSeq => NodeSeq.

    Wrap a function and make sure it's a NodeSeq => NodeSeq. Much easier than explicitly casting the first parameter

    f

    the function

    returns

    a NodeSeq => NodeSeq

  3. object AU extends CurrencyZone
  4. object AltXML
  5. object AnyVar
  6. object AvoidTypeErasureIssues1

    The companion object that does the implicit vending of AvoidTypeErasureIssues1

  7. object BasicTypesHelpers extends BasicTypesHelpers with StringHelpers with ControlHelpers

    This object adds functionality to Scala standard types.

  8. object BundleBuilder

    Converts a NodeSeq of a particular format into a ResourceBundle.

    Converts a NodeSeq of a particular format into a ResourceBundle. Basically, each of the second-level nodes that contain the attribute "name" the name becomes an entry in the resulting resource bundle. It is possible to localize each of the entries with the lang and country attributes which will be compared against the incoming Locale. If the default attribute is true, then that entry is used if no others match. Note that language is weighted more heavily than country.

    If the node is a Text or PCData node, it will be returned as a String. Otherwise, it will be returned as a NodeSeq.

  9. object CSSHelpers extends ControlHelpers
  10. object CSSParser
  11. object CanBind extends CssBindImplicits
  12. object CanResolveAsync extends LowPriorityCanResolveAsyncImplicits
  13. object Cell
  14. object CheckNodeSeq
  15. object ClassHelpers extends ClassHelpers with ControlHelpers
  16. object ClearClearable extends ClearClearable

    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

  17. object ClearNodes extends (NodeSeq) ⇒ NodeSeq

    Replaces the nodes with an Empty NodeSeq.

    Replaces the nodes with an Empty NodeSeq. Useful for removing unused nodes

  18. object ControlHelpers extends ControlHelpers with ClassHelpers
  19. object ConvertableToDate
  20. object CssBind
  21. object CssSelectorParser extends PackratParsers with ImplicitConversions

    Parse a subset of CSS into the appropriate selector objects

  22. object Currency
  23. object DefaultConnectionIdentifier extends ConnectionIdentifier with Product with Serializable
  24. object DefaultDateTimeConverter extends DateTimeConverter

    A default implementation of DateTimeConverter that uses (Time)Helpers

  25. object Done extends Product with Serializable
  26. object DontMergeAttributes extends SubNode with Product with Serializable
  27. object EU extends CurrencyZone
  28. object FatLazy

    Companion object for FatLaxy.

  29. object FieldError extends Serializable
  30. object FuncCell

    The companion object for FuncCell (function cells)

  31. object GB extends CurrencyZone
  32. object HeadHelper

    This object provides functions to setup the head section of html documents.

  33. object Helpers extends TimeHelpers with StringHelpers with ListHelpers with SecurityHelpers with HtmlHelpers with HttpHelpers with IoHelpers with BasicTypesHelpers with ClassHelpers with ControlHelpers

    The Helpers object provides a lot of utility functions:

    The Helpers object provides a lot of utility functions:

    • Time and date
    • URL
    • Hash generation
    • Class instantiation
    • Control abstractions
    • Basic types conversions
    • XML bindings
  34. object Html5 extends Html5Parser with Html5Writer
  35. object Html5Constants
  36. object HtmlEntities

    Utilities for simplifying use of named HTML symbols.

  37. object HttpHelpers extends ListHelpers with StringHelpers
  38. object InMemoryCache

    Companion module for InMemoryCache

  39. object IoHelpers extends IoHelpers
  40. object IterableConst

    The companion object that does the helpful promotion of common collection types into an IterableConst, e.g.

    The companion object that does the helpful promotion of common collection types into an IterableConst, e.g. Iterable[NodeSeq], Seq[String], Box[String], and Option[String]

  41. object IterableFunc
  42. object JodaHelpers extends JodaHelpers
  43. object JsonCommand

    A helpful extractor to take the JValue sent from the client-side JSON stuff and make some sense of it.

  44. object LD

    Calculate the edit distance between words

  45. object LZ

    Sometimes, you want to do pattern matching against a lazy value.

    Sometimes, you want to do pattern matching against a lazy value. Why? Because, there may be parts of the pattern that must be evaluated first and if they evaluate successfully, you then want to test another part of the pattern. Thus, the LZ pattern match.

  46. object ListHelpers extends ListHelpers
  47. object LoggingAutoConfigurer

    Function object that can be used in Logger.setup

    Function object that can be used in Logger.setup

    Tries to determine which logging backend is available and configures it by using either defaults or a mode-dependent configuration file.

    To provide your own configuration, add either a log4j.props file or log4j.xml file to your classpath. If using logback, name it logback.xml

    If you want to provide a configuration file for a subset of your application or for a specific environment, Lift expects configuration files to be named in a manner relating to the context in which they are being used. The standard name format is:

      modeName.hostName.userName.filename.extension
    

    with hostName and userName being optional, and modeName being one of 'test', 'staging', 'production', 'pilot', 'profile', or 'default. Thus, if you name your log4j config file 'default.log4j.xml' or 'default.log4j.props' it will be picked up correctly.

  48. object Mailer extends Mailer

    Utilities for sending email.

  49. object Maker
  50. object MarkdownParser
  51. object MonadicConversions

    Holds the implicit conversions from/to MonadicCondition

  52. object NamedPF
  53. object NoCache extends TemplateCache[(Locale, List[String]), NodeSeq]

    A cache that caches nothing

  54. object PCDataXmlParser
  55. object PValueHolder
  56. object PassThru extends (NodeSeq) ⇒ NodeSeq

    A passthrough function that does not change the nodes

  57. object ProcessQueue extends Product with Serializable
  58. object Props extends Props

    Configuration management utilities.

    Configuration management utilities.

    If you want to provide a configuration file for a subset of your application or for a specific environment, Lift expects configuration files to be named in a manner relating to the context in which they are being used. The standard name format is:

    $modeName.$userName.$hostName.$props
    
    examples:
    dpp.yak.props
    test.dpp.yak.props
    production.moose.props
    staging.dpp.props
    test.default.props
    default.props

    with hostName and userName being optional, and modeName being one of "test", "staging", "production", "pilot", "profile", or "default". The standard Lift properties file extension is "props".

  59. object RE

    A regular expressions helper library RE("foo") =~ "A string" -or- "A string" =~: RE("foo") -or- "A String".substring(RE("Str")) ("A B cat D" =~: RE("([A-Z])")).capture // List(A,B,D)

  60. object REMatcher
  61. object RestoringWeakReference
  62. object Safe

    Manage the current "safety" state of the stack

  63. object SafeNodeSeq

    Used for type-safe pattern matching of an Any and returns a Seq[Node]

  64. object Schedule extends Schedule

    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

  65. object Scheduled extends Product with Serializable

    Send to the actor that we scheduled for recurrent ping

  66. object SecurityHelpers extends StringHelpers with IoHelpers with SecurityHelpers
  67. object SoftReferenceCache

    Companion module that has the role of monitoring garbage collected references and remove the orphaned keys from the cache.

    Companion module that has the role of monitoring garbage collected references and remove the orphaned keys from the cache. The monitor is started by calling initialize function and terminated by calling shutDown. It monitors all SoftReferenceCache instances in the context of the same classloader. It can also be used as a factory for obtaining new instances of SoftReferenceCache class

  68. object StringHelpers extends StringHelpers
  69. object StringPromotable
  70. object SubNode
  71. object ThreadLazy
  72. object TimeHelpers extends TimeHelpers with ControlHelpers with ClassHelpers

    The TimeHelpers object extends the TimeHelpers.

    The TimeHelpers object extends the TimeHelpers. It can be imported to access all of the trait functions.

  73. object True extends MonadicCondition with Product with Serializable
  74. object US extends CurrencyZone
  75. object UnSchedule extends Product with Serializable

    Send by the scheduled actor to sign off from recurrent scheduling

  76. object VCardParser extends Parsers

    Parser for a VCard string such as

    Parser for a VCard string such as

    BEGIN:VCARD VERSION:2.1 N:Gump;Forrest FN:Forrest Gump ORG:Bubba Gump Shrimp Co. TITLE:Shrimp Man TEL;WORK;VOICE:(111) 555-1212 TEL;HOME;VOICE:(404) 555-1212 ADR;WORK:;;100 Waters Edge;Baytown;LA;30314;United States of America END:VCARD

  77. object ValueCell

    The companion object that has a helpful constructor

  78. object ValueHolder
  79. object Vendor

    A companion to the Vendor trait

Inherited from AnyRef

Inherited from Any

Ungrouped