net.liftweb

util

package util

The util package object

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. util
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
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

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

  14. class BCrypt extends AnyRef

  15. trait BaseField extends SettableField with FieldContainer

  16. trait BasicTypesHelpers extends AnyRef

    This trait adds functionality to Scala standard types

  17. trait BindHelpers extends AnyRef

    Helpers assocated with bindings

  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. case class CSSParser(prefix: String) extends Parsers with Product with Serializable

    Combinator parser for prefixing root relative paths with a given prefix

  21. trait CanBind[-T] extends AnyRef

  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

    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. final class CssJBridge extends AnyRef

    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. class Currency extends AnyRef

    A simple fixed-point currency representation

  40. class CurrencyMismatchException extends Exception

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

  41. abstract class CurrencyZone extends AnyRef

  42. trait DateTimeConverter extends AnyRef

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

  43. sealed trait DeltaInfo[T] extends AnyRef

    Provide information about the deltas between two lists

  44. trait Dependent extends AnyRef

    Something that depends on the values of other cells

  45. trait DollarCurrency extends TwoFractionDigits

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

  47. trait DynoVar[T] extends AnyRef

  48. final case class ElemSelector(elem: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable

  49. final case class EnclosedSelector(selector: CssSelector, kid: CssSelector) extends CssSelector with Product with Serializable

  50. abstract class EnumWithDescription extends AnyRef

  51. case class False(msgs: List[String]) extends MonadicCondition with Product with Serializable

  52. class FatLazy[T] extends AnyRef

    A class that does lazy evaluation

  53. trait FieldContainer extends AnyRef

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

    Associate a FieldIdentifier with a NodeSeq

  55. trait FieldIdentifier extends AnyRef

    Defines the association of this reference with a markup tag ID

  56. case class FormBuilderLocator[T](func: (T, (T) ⇒ Unit) ⇒ NodeSeq)(implicit manifest: Manifest[T]) extends Product with Serializable

  57. final case class FuncCell1[A, Z](a: Cell[A], f: (A) ⇒ Z) extends Cell[Z] with Product with Serializable

  58. final case class FuncCell2[A, B, Z](a: Cell[A], b: Cell[B], f: (A, B) ⇒ Z) extends Cell[Z] with Product with Serializable

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

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

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

  62. trait HasCalcDefaultValue[T] extends AnyRef

  63. trait HasParams extends AnyRef

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

  65. trait Html5Writer extends AnyRef

  66. trait HttpHelpers extends AnyRef

  67. final case class IdSelector(id: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable

  68. class InMemoryCache extends TemplateCache[(Locale, List[String]), NodeSeq]

    Caches templates in a LRU map

  69. trait Injector extends AnyRef

    A trait that does basic dependency injection.

  70. final case class InsertAfterDelta[T](item: T, after: T) extends DeltaInfo[T] with Product with Serializable

  71. final case class InsertAtStartDelta[T](item: T) extends DeltaInfo[T] with Product with Serializable

  72. trait IoHelpers extends AnyRef

  73. trait IterableConst extends AnyRef

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

  74. sealed trait IterableFunc extends (NodeSeq) ⇒ Seq[NodeSeq]

  75. trait JodaHelpers extends AnyRef

  76. case class JsonCmd(command: String, target: String, params: Any, all: Map[String, Any]) extends Product with Serializable

    Impersonates a JSON command

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

  78. final case class KidsSubNode() extends SubNode with WithKids with Product with Serializable

  79. class LRU[KeyType, ValueType] extends LRUMap[KeyType, ValueType]

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

  80. class LZ[T] extends AnyRef

    LZ encapsulates a lazy value.

  81. class LiftFlowOfControlException extends RuntimeException

    The superclass for all Lift flow of control exceptions

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

  83. trait ListHelpers extends AnyRef

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

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

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

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

  87. class MakerJ extends AnyRef

  88. class MakerStack[T] extends StackableMaker[T]

    An implementation where you can define the stack of makers.

  89. trait MemoizeVar[K, V] extends AnyRef

  90. 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"
      })
    

  91. final case class NameSelector(name: String, subNodes: Box[SubNode]) extends CssSelector with Product with Serializable

  92. class NamedPF[-A, +B] extends NamedPartialFunction[A, B]

    This class is the base implementation of the NamedPartialFunction trait.

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

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

    The implementation for a NodeSeq => NodeSeq Iterable Const

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

    The implementation for a NodeSeq Iterable Const

  96. abstract class NonCleanAnyVar[T] extends AnyVar[T, NonCleanAnyVar[T]]

  97. final case class OptionNodeSeqFuncIterableConst(it: Option[(NodeSeq) ⇒ NodeSeq]) extends IterableConst with Product with Serializable

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

  98. final class OptionalCons extends AnyRef

    Optional cons that implements the expression: expr ?> value ::: List

    Optional cons that implements the expression: expr ?> value ::: List

  99. case class PCData(_data: String) extends Atom[String] with Product with Serializable

  100. trait PCDataMarkupParser[PCM <: MarkupParser with MarkupHandler] extends MarkupParser

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

  101. class PCDataXmlParser extends ConstructingHandler with PCDataMarkupParser[PCDataXmlParser] with ExternalSources

  102. trait PSettableValueHolder[T] extends PValueHolder[T] with SettableValueHolder

  103. trait PValueHolder[T] extends ValueHolder

  104. final class PartialFunctionWrapper[A] extends AnyRef

    The helper class that facilitates wrapping of one PartialFunction around another

  105. final case class PrependKidsSubNode() extends SubNode with WithKids with Product with Serializable

  106. class REDoer[T] extends (T, String) ⇒ Box[T]

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

  108. trait ReadableField extends FieldIdentifier with ValueHolder with Bindable

    A field that can be displayed but not edited

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

  110. class ResponseInfoHolder extends AnyRef

    Holds information about a response

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

  112. trait SafeSeqParser extends Parsers

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

  114. class ScheduleJBridge extends AnyRef

  115. 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 hashs (can be hex encoded)
  116. final case class SelectThisNode(kids: Boolean) extends SubNode with Product with Serializable

  117. final case class SeqBindableIterableConst(it: Iterable[Bindable]) extends IterableConst with Product with Serializable

    Sequence of Bindable iterable const

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

    A collection of Cells og a given type

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

    Sequence of String iterable const

  120. trait Settable extends ValueHolder

    A value that can be set

  121. trait SettableField extends ReadableField with SettableValueHolder

    A field that can be set

  122. trait SettableValueHolder extends Settable

  123. trait SimpleInjector extends Injector

    An implementation of Injector that has an implementation

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

  125. class SoftValue[K, V] extends SoftReference[V]

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

  127. final case class StarSelector(subNodes: Box[SubNode], singleDepth: Boolean) extends CssSelector with Product with Serializable

  128. trait StringHelpers extends AnyRef

    Utility methods for manipulating strings.

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

  130. trait StringValidators extends AnyRef

  131. sealed trait SubNode extends AnyRef

  132. final class SuperListString extends AnyRef

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

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

    The SuperString class adds functionalities to the String class

  134. final case class SurroundKids() extends SubNode with WithKids with Product with Serializable

  135. trait TemplateCache[K, V] extends AnyRef

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

  137. class ThreadLazy[TheType] extends LoanWrapper

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

  138. trait TimeHelpers extends AnyRef

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

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

  139. final case class ToCssBindPromoter(stringSelector: Box[String], css: Box[CssSelector]) extends Product with Serializable

    An intermediate class used to promote a String or a CssSelector to something that can be associated with a value to apply to the selector

  140. trait ToJsCmd extends AnyRef

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

  141. trait TwoFractionDigits extends AnyRef

  142. final class ValueCell[A] extends Cell[A] with LiftValue[A]

    A ValueCell holds a value that can be mutated.

  143. trait ValueHolder extends AnyRef

  144. trait ValueWithDescription extends AnyRef

  145. trait Vendor[T] extends Maker[T] with () ⇒ T

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

  146. final class VendorJ extends AnyRef

  147. class VendorJBridge extends AnyRef

    A bridge from Java to Scala

  148. sealed trait WithKids extends AnyRef

Value Members

  1. object AU extends CurrencyZone

  2. object AltXML

  3. object AnyVar

  4. object AvoidTypeErasureIssues1

    The companion object that does the implicit vending of AvoidTypeErasureIssues1

  5. object BasicTypesHelpers extends BasicTypesHelpers with StringHelpers with ControlHelpers

    This object adds functionality to Scala standard types.

  6. object BindHelpers extends BindHelpers

    BindHelpers can be used to obtain additional information while a bind call is executing.

    BindHelpers can be used to obtain additional information while a bind call is executing. This informaiton includes node attributes of the current bound node or the entire NodeSeq that is to be bound. Since the context is created during bind execution and destroyed when bind terminates, you can benefit of these helpers in the context of FuncBindParam or FuncAttrBindParam. You can also provide your own implementation of BindParam and your BindParam#calcValue function will be called in the appropriate context.

    Example:

    bind("hello", xml,
         "someNode" -> {node: NodeSeq => })
    

    In function-body you can safely use BindHelpers methods to obtain correctly-scoped information.

  7. object BindPlus

  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 CanBind

  11. object Cell

  12. object CheckNodeSeq

  13. object ClassHelpers extends ClassHelpers with ControlHelpers

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

  15. object ClearNodes extends (NodeSeq) ⇒ NodeSeq

    Replaces the nodes with an Empty NodeSeq.

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

  16. object ControlHelpers extends ControlHelpers with ClassHelpers

  17. object ConvertableToDate

  18. object CssBind

  19. object CssSelectorParser extends PackratParsers with ImplicitConversions

    Parse a subset of CSS into the appropriate selector objects

  20. object Currency

  21. object DefaultConnectionIdentifier extends ConnectionIdentifier with Product with Serializable

  22. object DefaultDateTimeConverter extends DateTimeConverter

    A default implementation of DateTimeConverter that uses (Time)Helpers

  23. object Done extends Product with Serializable

  24. object DontMergeAttributes extends SubNode with Product with Serializable

  25. object EU extends CurrencyZone

  26. object FatLazy

    Companion object for FatLaxy.

  27. object FieldError extends Serializable

  28. object FuncCell

    The companion object for FuncCell (function cells)

  29. object GB extends CurrencyZone

  30. object HeadHelper

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

  31. object Helpers extends TimeHelpers with StringHelpers with ListHelpers with SecurityHelpers with BindHelpers 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
  32. object Html5 extends Html5Parser with Html5Writer

  33. object Html5Constants

  34. object HtmlEntities

    Utilities for simplifying use of named HTML symbols.

  35. object HttpHelpers extends ListHelpers with StringHelpers

  36. object InMemoryCache

    Companion module for InMemoryCache

  37. object IoHelpers extends IoHelpers

  38. object IterableConst

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

    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]

  39. object IterableFunc

  40. object JodaHelpers extends JodaHelpers

  41. object JsonCommand

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

  42. object LD

    Calculate the edit distance between words

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

  44. object ListHelpers extends ListHelpers

  45. object LoggingAutoConfigurer

    Function object that can be used in Logger.

    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.

  46. object Mailer extends Mailer

    Utilities for sending email.

  47. object Maker

  48. object MonadicConversions

    Holds the implicit conversions from/to MonadicCondition

  49. object NamedPF

  50. object NoCache extends TemplateCache[(Locale, List[String]), NodeSeq]

    A cache that caches nothing

  51. object PCDataXmlParser

  52. object PValueHolder

  53. object PassThru extends (NodeSeq) ⇒ NodeSeq

    A passthrough function that does not change the nodes

  54. object ProcessQueue extends Product with Serializable

  55. object Props extends Logger

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

  56. object RE

    A regular expressions helper library RE("foo") =~ "A string" -or- "A string" =~: RE("foo") -or- "A String".

    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)

  57. object REMatcher

  58. object RestoringWeakReference

  59. object Safe

    Manage the current "safety" state of the stack

  60. object SafeNodeSeq

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

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

  62. object Scheduled extends Product with Serializable

    Send to the actor that we scheduled for recurrent ping

  63. object SecurityHelpers extends StringHelpers with IoHelpers with SecurityHelpers

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

  65. object StringHelpers extends StringHelpers

  66. object StringPromotable

  67. object SubNode

  68. object ThreadLazy

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

  70. object True extends MonadicCondition with Product with Serializable

  71. object US extends CurrencyZone

  72. object UnSchedule extends Product with Serializable

    Send by the scheduled actor to sign off from recurrent scheduling

  73. object VCardParser extends Parsers

    Parser a VCard entry such as

    Parser a VCard entry 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

  74. object ValueCell

    The companion object that has a helpful constructor

  75. object ValueHolder

  76. object Vendor

    A companion to the Vendor trait

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

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

Deprecated Value Members

  1. val ActorPing: Schedule.type

    Changed the name ActorPing to Schedule

    Changed the name ActorPing to Schedule

    Annotations
    @deprecated
    Deprecated

    (Since version 2.3) Use Schedule

  2. object JSONParser extends SafeSeqParser with ImplicitConversions

    Annotations
    @deprecated
    Deprecated

    (Since version 2.5) Use lift-json instead

Inherited from AnyRef

Inherited from Any

Ungrouped