Helpers

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object AsBoolean

A helpful Boolean extractor

object AsDouble

A helpful Double extractor

object AsInt

A helpful Int extractor

object AsLong

A helpful Long extractor

object AttrBindParam

BindParam that binds a given value into a new attribute.

object BooleanBindParam extends Serializable

object BoxBindParam extends Serializable

object FuncAttrBindParam

BindParam using a function to calculate its value.

object FuncAttrBoxBindParam

BindParam that computes an optional new attribute value based on the current attribute value.

object FuncAttrOptionBindParam

BindParam that computes an optional new attribute value based on the current attribute value.

object FuncBindParam extends Serializable

object IntBindParam extends Serializable

object LongBindParam extends Serializable

object OptionBindParam extends Serializable

object SymbolBindParam extends Serializable

object TheBindParam extends Serializable

object TheBindableBindParam extends Serializable

object TheStrBindParam extends Serializable

object TimeSpan

The TimeSpan object provides class represents an amount of time.

def ^[T](i: T*): List[T]

This operator transforms its arguments into a List

def addAttributes(in: NodeSeq, attributes: MetaData): NodeSeq

takes a NodeSeq and applies all the attributes to all the Elems at the top level of the NodeSeq.

def addCssClass(cssClass: String, elem: Elem): Elem

Adds a css class to the existing class tag of an Elem or create the class attribute

def addCssClass(cssClass: Box[String], elem: Elem): Elem

Adds a css class to the existing class tag of an Elem or create the class attribute

def appendFuncToURL(url: String, funcStr: String): String

Given a URL and a Lift function String, append the function even if the URL has query params and a #

def appendParams(url: String, params: Seq[(String, String)]): String

Append parameters to a URL

def appendQueryParameters(url: String, params: List[(String, String)]): String

Given a list of query parameters, append them to the URL taking into account # and if there are any other query parameters

def asBoolean(in: String): Box[Boolean]

A helper that will convert the String to a Boolean if it's t, true, yes, 1, f, false, no, or 0

def asDouble(in: String): Box[Double]

Safely convert the specified String to a Double.

final def asInstanceOf[T0]: T0

def asInt(in: String): Box[Int]

Safely convert the specified String to an Int.

def asLong(in: Any): Box[Long]

Convert any object to an "equivalent" Long depending on its value

def asLong(in: String): Box[Long]

Safely convert the specified String to a Long.

def base64Decode(in: String): Array[Byte]

decode a String in Base 64

def base64Encode(in: Array[Byte]): String

encode a Byte array in Base 64

def base64EncodeURLSafe(in: Array[Byte]): String

encode a Byte array in Base 64 in a way that's safe for use in URLs

def bind(vals: Map[String, NodeSeq], xml: NodeSeq): NodeSeq

Replace the content of lift:bind nodes with the corresponding nodes found in a map, according to the value of the "name" attribute.

  bind(Map("a" ->
= ), change this) must ==/(
=  =
)

def bind(namespace: String, nodeFailureXform: Box[(NodeSeq) ⇒ NodeSeq], paramFailureXform: Box[(PrefixedAttribute) ⇒ MetaData], preserveScope: Boolean, xml: NodeSeq, params: BindParam*): NodeSeq

Bind a set of values to parameters and attributes in a block of XML with defined transforms for unbound elements within the specified namespace.

  bind("user",
       Full(xhtml: NodeSeq => Text("Default Value")),
       Empty,
       replace thisreplace with default,
       "hello" ->
= )

=  =
Default Value

def bind(namespace: String, nodeFailureXform: Box[(NodeSeq) ⇒ NodeSeq], paramFailureXform: Box[(PrefixedAttribute) ⇒ MetaData], xml: NodeSeq, params: BindParam*): NodeSeq

Bind a set of values to parameters and attributes in a block of XML with defined transforms for unbound elements within the specified namespace.

  bind("user",
       Full(xhtml: NodeSeq => Text("Default Value")),
       Empty,
       replace thisreplace with default,
       "hello" ->
= )

=  =
Default Value

def bind(namespace: String, xml: NodeSeq, params: BindParam*): NodeSeq

Bind a set of values to parameters and attributes in a block of XML.

  bind("user", replace this, "hello" ->
= )

=  =

def bindlist(listvals: List[Map[String, NodeSeq]], xml: NodeSeq): Box[NodeSeq]

Bind a list of name/xml maps to a block of XML containing lift:bind nodes (see the bind(Map, NodeSeq) function)

def blankForNull(s: String): String

Test for null and return either the given String if not null or the blank String.

implicit def boolean2(b: ⇒ Boolean): Boolean2

Allows an implicit transform from a Boolean to a Boolean2, allowing expressions such as: (1 == 2) ? "a" | "b" (This expression will return "b")

def boxParseInternetDate(dateString: String): Box[Date]

def calcTime[T](f: ⇒ T): (Long, T)

def callableMethod_?(meth: Method): Boolean

def camelify(name: String): String

Turns a string of format "foo_bar" into camel case "FooBar"

def camelifyMethod(name: String): String

Turn a string of format "foo_bar" into camel case with the first letter in lower case: "fooBar" This function is especially used to camelCase method names.

def capify(in: String): String

Capitalize every "word" in the string.

def charSplit(what: String, sep: Char): List[String]

Faster than roboSplit.

def chooseTemplate(prefix: String, tag: String, xhtml: NodeSeq): NodeSeq

Finds and returns one of many templates from the children based upon the namespace and tag name: for example, for prefix "choose" and tag name "stuff" this would return the contents of the first tag <choose:stuff> ... </choose:stuff> in the specified NodeSeq.

def classHasControllerMethod(clz: Class[_], name: String): Boolean

Check that the method 'name' is callable for class 'clz'

def classHierarchy(in: Class[_]): List[Class[_]]

def clean(in: String): String

Remove all the characters from a string exception a-z, A-Z, 0-9, and '_'

def clone(): AnyRef

def commafy(what: String): String

Add commas before the last 3 characters

def compareElem(left: Elem, right: Elem): Boolean

Compare two Elems

def compareMetaData(left: List[MetaData], right: List[MetaData]): Boolean

Compare the metadata of two attributes

def compareNode(left: Node, right: Node): Boolean

Comparse two XML nodes

def compareXml(left: NodeSeq, right: NodeSeq): Boolean

Compare two NodeSeq and return true if they are equal, even if attribute order of Elems is different

def containsClass[C](clz: Class[C], toMatch: List[Class[_]]): Boolean

Is the clz an instance of (assignable from) any of the classes in the list

def couldBeHtml(in: Map[String, String]): Boolean

Given a map of HTTP properties, return true if the "Content-type" value in the map is either "text/html" or "application/xhtml+xml"

def createInvoker[C <: AnyRef](name: String, on: C): Box[() ⇒ Box[Any]]

Create a function (the 'invoker') which will trigger any public, parameterless method That function will throw the cause exception if the method can't be invoked

implicit def cssSelectorToCssBindPromoter(sel: CssSelector): ToCssBindPromoter

promote a String to a ToCssBindPromotor

def currentYear: Int

def dateFormatter: SimpleDateFormat

def day(in: Date): Int

def days(in: Long): Long

def daysSinceEpoch: Long

def deepEnsureUniqueId(in: NodeSeq): NodeSeq

For a list of NodeSeq, ensure that the the id of the root Elems are unique.

def deepFindKids(in: NodeSeq, prefix: String, label: String): NodeSeq

def delta[T, Res](old: Seq[T], newList: Seq[T])(f: (DeltaInfo[T]) ⇒ Res): List[Res]

Compute the deltas between two sequences of a given type.

def delta[T, Res](old: Box[Seq[T]], newList: Seq[T])(f: (DeltaInfo[T]) ⇒ Res): List[Res]

Compute the deltas between two sequences of a given type.

def doClose[T](is: Closeable*)(f: ⇒ T): T

Executes by-name function f and then closes the Cloaseables parameters

def emptyForBlank(s: String): Box[String]

Turn a String into a Box[String], with Empty for the blank string.

def encJs(what: String): String

Encode the string to be including in JavaScript, replacing '\' or '\\' or non-ASCII characters by their unicode value

def ensureId(ns: NodeSeq, id: String): NodeSeq

Ensure that the first Element has the specified ID

def ensureUniqueId(in: Seq[NodeSeq]): Seq[NodeSeq]

For a list of NodeSeq, ensure that the the id of the root Elems are unique.

def enumToList[T](enum: Enumeration[T]): List[T]

Convert a java.

def enumToStringList[C](enum: Enumeration[C]): List[String]

Convert a java.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorDiv(body: NodeSeq): Box[NodeSeq]

def escChar(in: Char): String

Create the unicode value of a character

def evalElemWithId(f: (String, Elem) ⇒ NodeSeq)(ns: NodeSeq): NodeSeq

Within a NodeSeq, find the first elem and run it through the function.

def exec(cmds: String*): Box[String]

Execute the specified OS command and return the output of that command in a Full Box if the command succeeds, or a Failure if an error occurs.

def finalize(): Unit

def findBox[T](nodes: Seq[Node])(f: (Elem) ⇒ Box[T]): Box[T]

Given a NodeSeq and a function that returns a Box[T], return the first value found in which the function evaluates to Full

def findClass(where: List[(String, List[String])]): Box[Class[AnyRef]]

Find a class given a list of possible names and corresponding packages, turning underscored names to CamelCase if necessary

def findClass(name: String, where: List[String]): Box[Class[AnyRef]]

Find a class given its name and a list of packages, turning underscored names to CamelCase if necessary.

def findClass[C <: AnyRef](name: String, where: List[String], targetType: Class[C]): Box[Class[C]]

Find a class given its name and a list of packages, turning underscored names to CamelCase if necessary.

def findClass(name: String, where: List[String], modifiers: List[(String) ⇒ String]): Box[Class[AnyRef]]

General method to in find a class according to its name, a list of possible packages and a list of functions modifying the given name create a target name to look for (e.

def findClass[C <: AnyRef](name: String, where: List[String], modifiers: List[(String) ⇒ String], targetType: Class[C]): Box[Class[C]]

General method to in find a class according to its name, a list of possible packages, a list of functions modifying the given name create a target name to look for (e.

def findElems(nodes: NodeSeq)(f: (Elem) ⇒ Boolean): NodeSeq

Find the elements of the specified NodeSeq that match the specified predicate and concatenate them into a resulting NodeSeq.

def findId(ns: NodeSeq): Box[String]

Finds the first Element in the NodeSeq (or any children) that has an ID attribute

def findId(nodes: Seq[Node], id: String): Option[Elem]

Given an id value, find the Elem with the specified id

def findInElems[T](nodes: NodeSeq)(f: (Elem) ⇒ Iterable[T]): List[T]

Map the specified function over the elements of the specified NodeSeq and return the concatenated result.

def findKids(in: NodeSeq, prefix: String, label: String): NodeSeq

def findNode(in: Elem, nodes: NodeSeq): Box[Elem]

Finds and returns the first node in the specified NodeSeq and its children with the same label and prefix as the specified element.

def findOption[T](nodes: Seq[Node])(f: (Elem) ⇒ Option[T]): Option[T]

Given a NodeSeq and a function that returns an Option[T], return the first value found in which the function evaluates to Some

def findOrAddId(in: Elem): (Elem, String)

If the specified Elem has an attribute named 'id', return it, otherwise construct a new Elem with a randomly generated id attribute and return the pair

def findOrCreateId(f: (String) ⇒ (NodeSeq) ⇒ NodeSeq): (NodeSeq) ⇒ NodeSeq

Find the first Elem in the NodeSeq.

def findType[C <: AnyRef](where: List[(String, List[String])])(implicit m: Manifest[C]): Box[Class[C]]

Find a class given its type, a list of possible names and corresponding packages, turning underscored names to CamelCase if necessary

def findType[C <: AnyRef](name: String, where: List[String])(implicit m: Manifest[C]): Box[Class[C]]

Find a class given its type, its name and a list of packages, turning underscored names to CamelCase if necessary.

def findType[C <: AnyRef](name: String, where: List[String], modifiers: List[(String) ⇒ String])(implicit m: Manifest[C]): Box[Class[C]]

General method to in find a class according to its type, its name, a list of possible packages and a list of functions modifying the given name create a target name to look for (e.

def first[B, C](in: Seq[B])(_f: (B) ⇒ Box[C]): Box[C]

Returns the first application of f to an element of in that results in a Full Box.

def first_?[B](in: Seq[B])(f: ⇒ (B) ⇒ Boolean): Box[B]

Returns a Full Box with the first element x of the list in for which f(x) evaluates to true.

def formattedDateNow: String

def formattedTimeNow: String

final def getClass(): Class[_]

def hash(in: String): String

create a SHA hash from a String

def hash(in: Array[Byte]): Array[Byte]

create a SHA hash from a Byte array

def hash256(in: String): String

create a SHA-256 hash from a String

def hash256(in: Array[Byte]): Array[Byte]

create a SHA-256 hash from a Byte array

def hashCode(): Int

def hashHex(in: String): String

create a SHA hash from a String

def head[T](l: Seq[T], deft: ⇒ T): T

Return the first element of a List or a default value if the list is empty

def hexDecode(str: String): Array[Byte]

def hexDigest(in: Array[Byte]): String

create an hex encoded SHA hash from a Byte array

def hexDigest256(in: Array[Byte]): String

create an hex encoded SHA-256 hash from a Byte array

def hexEncode(in: Array[Byte]): String

encode a Byte array as hexadecimal characters

def hourFormat(in: Date): String

def hourFormat: SimpleDateFormat

def hours(in: Long): Long

def instantiate[C](clz: Class[C]): Box[C]

Create a new instance of a class

def insureField(toInsure: List[(String, String)], headers: List[(String, String)]): List[(String, String)]

Ensure that all the appropriate fields are in the header.

implicit def intToTimeSpan(in: Int): TimeSpan

transforms an int to a TimeSpan object.

implicit def intToTimeSpanBuilder(in: Int): TimeSpanBuilder

transforms an int to a TimeSpanBuilder object.

def internetDateFormatter: SimpleDateFormat

def invokeControllerMethod(clz: Class[_], meth: String): Any

Invoke a controller method (parameterless, public) on a class

def invokeMethod[C](clz: Class[C], inst: AnyRef, meth: String, params: Array[AnyRef], ptypes: Array[Class[_]]): Box[Any]

Invoke the given method for the given class, with some parameters and their types Tries the method name, then the method as a CamelCased name and the method as a camelCased name The class is not instanciated if the method is static, otherwise the passed instance is used

def invokeMethod[C](clz: Class[C], inst: AnyRef, meth: String, params: Array[AnyRef]): Box[Any]

Invoke the given method for the given class, with some parameters.

def invokeMethod[C](clz: Class[C], inst: AnyRef, meth: String): Box[Any]

Invoke the given method for the given class, with no params.

def isEq(a: Array[Byte], b: Array[Byte]): Boolean

Compare two arrays of Byte for byte equality.

final def isInstanceOf[T0]: Boolean

val knownSuffixes: Set[String]

The list of known suffixes used to split the URI into path parts and suffixes.

def listFromListAndString(lst: List[String], s: String): List[String]

Creates a List of Strings from a List[String] and a String

def listFromStrings(s1: String, s2: String): List[String]

Creates a List of Strings from two Strings

def listIf[T](expr: Boolean)(f: ⇒ T): List[T]

Return a list containing the element f if the expression is true

implicit def listStringToSuper(in: List[String]): SuperListString

implicit def listToListMapish(in: Seq[(String, String)]): ListMapish

adds the ciGet method to a List of Pairs of Strings

def logTime[T](f: ⇒ (String, T)): T

Call f and log the string returned together with the time taken in millis.

def logTime[T](msg: String)(f: ⇒ T): T

Log a message with the time taken in millis to do something and return the result

implicit def longToTimeSpan(in: Long): TimeSpan

transforms a long to a TimeSpan object.

implicit def longToTimeSpanBuilder(in: Long): TimeSpanBuilder

transforms a long to a TimeSpanBuilder object.

def md5(in: String): String

create a MD5 digest from a String

def md5(in: Array[Byte]): Array[Byte]

create a MD5 digest from a Byte array

def millis: Long

def millisToDays(millis: Long): Long

def minutes(in: Long): Long

def mixinAttributes(out: Elem)(in: NodeSeq): NodeSeq

Takes attributes from the first node of 'in' (if any) and mixes them into 'out'.

def month(in: Date): Int

def nano: Long

final def ne(arg0: AnyRef): Boolean

def nextFuncName(seed: Long): String

Get a guaranteed unique field name (16 or 17 letters and numbers, starting with a letter)

def nextFuncName: String

Get a guaranteed unique field name (16 or 17 letters and numbers, starting with a letter)

def nextNum: Long

Get a monotonically increasing number that's guaranteed to be unique for the current session

def noHtmlTag(in: NodeSeq): Boolean

Return true if the xml doesn't contain an <html> tag

implicit def nodeSeqToOptionString(in: NodeSeq): Box[String]

def notEq(a: Array[Byte], b: Array[Byte]): Boolean

Compare two arrays of Byte for byte equality.

final def notify(): Unit

final def notifyAll(): Unit

def now: Date

def nowAsInternetDate: String

implicit def pairToUnprefixed(in: (String, Any)): MetaData

Transform a pair (name: String, value: Any) to an unprefixed XML attribute name="value"

def paramsToUrlParams(params: List[(String, String)]): String

Take a list of name/value parse and turn them into a URL query string

def parseInternetDate(dateString: String): Date

def parseNumber(tin: String): Long

Parse a string and return the Long value of that string.

def permuteList[T](in: Seq[T]): List[List[T]]

Given a list, return all the permutations of the list.

def permuteWithSublists[T](in: Seq[T]): List[List[T]]

Given a list, return all the permutations including the removal of items (does not return a Nil list unless in is Nil).

implicit def pfToGuardable[A](in: PartialFunction[A, _]): PartialFunctionWrapper[A]

promote a partial function such that we can invoke the guard method to wrap the guarded partial function with a guard

def processString(msg: String, subst: Map[String, String]): String

Replaces the value found in a string surrounded by <%= .

def randomInt(mod: Int): Int

return a random int modulo a number

def randomLong(mod: Long): Long

return a random Long modulo a number

def randomString(size: Int): String

Create a random string of a given size.

def readWholeFile(file: File): Array[Byte]

Read an entire file into an Array[Byte]

def readWholeStream(in: InputStream): Array[Byte]

Read all data from a stream into an Array[Byte]

def readWholeThing(in: Reader): String

Read all data to the end of the specified Reader and concatenate the resulting data into a string.

def replaceIdNode(in: NodeSeq, id: String, replacement: NodeSeq): NodeSeq

Replace the element with the id that matches with the replacement nodeseq.

def roboSplit(what: String, sep: String): List[String]

Split a string according to a separator

def rotateList[T](in: Seq[T]): List[List[T]]

Given an incoming list, return a set of lists that is the original list rotated through all its positions

def seconds(in: Long): Long

def secureEquals(s1: Array[Byte], s2: Array[Byte]): Boolean

Compare two byte arrays in a way that does not vary if the arrays are determined to be not equal early (test every byte.

def secureEquals(s1: String, s2: String): Boolean

Compare two strings in a way that does not vary if the strings are determined to be not equal early (test every byte.

def shouldShow(percent: Double): Boolean

return true only 'percent' times when asked repeatedly.

def snakify(name: String): String

Turn a string of format "FooBar" into snake case "foo_bar"

def splitAt(what: String, sep: String): List[(String, String)]

Split a string in 2 parts at the first place where a separator is found

def splitAtHash(str: String)(f: (String) ⇒ String): String

Split a String at the Hash sign, run the function on the non-# side and then append the hash side

def splitColonPair(in: String, first: String, second: String): (String, String)

Split a string separated by a point or by a column in 2 parts.

def splitNameValuePairs(props: String): Map[String, String]

Splits a string of the form <name1=value1, name2=value2, .

implicit def strToCssBindPromoter(str: String): ToCssBindPromoter

promote a String to a ToCssBindPromotor

implicit def strToSuperArrowAssoc(in: String): SuperArrowAssoc

implicit def stringToSuper(in: String): SuperString

def stripHead(in: NodeSeq): NodeSeq

Remove all the <head> tags, just leaving the child tags

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

def template(xhtml: NodeSeq, prefix: String, tag1: String, tag2: String, tag3: String): Box[(NodeSeq, NodeSeq, NodeSeq)]

Find three of many templates from the children

def template(xhtml: NodeSeq, prefix: String, tag1: String, tag2: String): Box[(NodeSeq, NodeSeq)]

Find two of many templates from the children

def template(xhtml: NodeSeq, prefix: String, tag: String): Box[NodeSeq]

Similar to chooseTemplate, this returns the contents of the element in a Full Box if found or an Empty Box otherwise.

def time(when: Long): Date

alias for new Date(millis)

def timeFormatter: SimpleDateFormat

def toBoolean(in: Any): Boolean

Convert any object to an "equivalent" Boolean depending on its value

def toByteArrayInputStream(in: InputStream): ByteArrayInputStream

Convert any InputStream to a ByteArrayInputStream

implicit def toCalendarExtension(c: Calendar): CalendarExtension

implicit def used to add the setXXX methods to the Calendar class

def toDate(in: Any): Box[Date]

implicit def toDateExtension(d: Date): DateExtension

implicit def used to add the noTime method to the Date class

def toHashMap[A, B](in: Map[A, B]): HashMap[A, B]

Transform a general Map to a nutable HashMap

def toInt(in: Any): Int

Convert any object to an "equivalent" Int depending on its value

def toInternetDate(in: Long): String

def toInternetDate(in: Date): String

def toLong(in: Any): Long

Convert any object to an "equivalent" Long depending on its value

implicit def toOptiCons(expr: ⇒ Boolean): OptionalCons

Implicit transformation from a Boolean expression to an OptionalCons object so that an element can be added to a list if the expression is true

def toString(): String

implicit def toSuperList[T](in: List[T]): SuperList[T]

Add utility methods to Lists

def today: Calendar

def tryo[T](ignore: Class[_])(f: ⇒ T): Box[T]

Wraps a "try" block around the function f.

def tryo[T](ignore: List[Class[_]])(f: ⇒ T): Box[T]

Wraps a "try" block around the function f

def tryo[T](onError: (Throwable) ⇒ Unit)(f: ⇒ T): Box[T]

Wraps a "try" block around the function f and trigger a callback function if an exception is thrown

def tryo[T](f: ⇒ T): Box[T]

Wraps a "try" block around the function f

def tryo[T](handler: PartialFunction[Throwable, T], f: ⇒ T): Box[T]

Wraps a "try" block around the function f.

def tryo[T](ignore: List[Class[_]], onError: Box[(Throwable) ⇒ Unit])(f: ⇒ T): Box[T]

Wraps a "try" block around the function f.

def unquote(str: String): String

If str is surrounded by quotes it return the content between the quotes

def urlDecode(in: String): String

URL decode the string.

def urlEncode(in: String): String

URL encode the string.

val utc: TimeZone

The UTC TimeZone

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def weeks(in: Long): Long

def xmlParam(in: NodeSeq, param: String): Box[String]

Finds the named attribute in specified XML element and returns a Full Box containing the value of the attribute if found.

def year(in: Date): Int

object BindParamAssoc

transforms a Box into a Text node

def camelCase(name: String): String

def camelCaseMethod(name: String): String

def dayNow: Date

def emptyForNull(s: String): String

def processBind(around: NodeSeq, atWhat: Map[String, NodeSeq]): NodeSeq

Bind parameters to XML.

implicit def strToBPAssoc(in: String): BindParamAssoc

transforms a String to a BindParamAssoc object which can be associated to a BindParam object using the --> operator.

implicit def symToSAAssoc(in: Symbol): SuperArrowAssoc

transforms a Symbol to a SuperArrowAssoc object which can be associated to a BindParam object using the -> operator.

def timeNow: Date

def unCamelCase(name: String): String

def xbind(namespace: String, xml: NodeSeq)(transform: PartialFunction[String, (NodeSeq) ⇒ NodeSeq]): NodeSeq

Experimental extension to bind which passes in an additional "parameter" from the XHTML to the transform function, which can be used to format the returned NodeSeq.