Lift Framework 3.2.0 - net.liftweb.http

trait AbstractScreen extends Factory with Loggable

The trait that forms the basis for LiftScreen and the Screen instances in Wizard

case class AcceptedResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

202 response but without body.

case class ActionMessageSet (msg: List[() ⇒ Any], req: Req) extends CometMessage with Product with Serializable

case class AddAListener (who: SimpleActor[Any], shouldUpdate: PartialFunction[Any, Boolean]) extends Product with Serializable

This is a message class for use with ListenerManager and CometListener instances.

This is a message class for use with ListenerManager and CometListener instances. The use of the shouldUpdate function is deprecated, and should instead be handled by the message processing partial functions on the CometListener instances themselves.

See also: ListenerManager
CometListener

case class AjaxContext (success: Box[String], failure: Box[String], responseType: AjaxType.Value) extends Product with Serializable

case class AnswerQuestion (what: Any, listeners: List[(ListenerId, (AnswerRender) ⇒ Unit)]) extends CometMessage with Product with Serializable

case class AnswerRender (response: XmlOrJsCmd, who: LiftCometActor, when: Long, displayAll: Boolean) extends CometMessage with Product with Serializable

case class AskQuestion (what: Any, who: LiftCometActor, listeners: List[(ListenerId, (AnswerRender) ⇒ Unit)]) extends CometMessage with Product with Serializable

case class AtomCategoryResponse (xml: Node) extends LiftResponse with Product with Serializable

Returning an Atom category document.

case class AtomCreatedResponse (xml: Node) extends LiftResponse with Product with Serializable

The Atom entity was successfully created and is shown to the client.

case class AtomResponse (xml: Node, addlHeaders: List[(String, String)] = XmlResponse.addlHeaders) extends XmlNodeResponse with Product with Serializable

Returning an Atom document.

case class AtomServiceResponse (xml: Node) extends LiftResponse with Product with Serializable

Returning an Atom Service Document.

case class BadGatewayResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

502 Bad Gateway

The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request.

case class BadRequestResponse (message: String = "") extends LiftResponse with HeaderDefaults with Product with Serializable

400 Bad Request

Your Request was missing an important element. Use this as a last resort if the request appears incorrect. Use the message to indicate what was wrong with the request, if that does not leak important information.

trait BaseCometActor extends LiftActor with LiftCometActor with CssBindImplicits

Takes care of the plumbing for building Comet-based Web Apps

sealed trait BasicResponse extends LiftResponse

trait BlankStatelessBehavior extends StatelessBehavior

A "default" implementation of StatelessBehavior.

A "default" implementation of StatelessBehavior. Just ignore everything and return an empty NodeSeq.

final case class BodyOrInputStream (is: InputStream) extends Product with Serializable

Holds either the body or the request input stream, depending on which was requested first

trait BooleanField extends FieldIdentifier

abstract class Bootable extends AnyRef

final case class BreakOut () extends Product with Serializable

case class CSSResponse (text: String, headers: List[(String, String)], code: Int) extends LiftResponse with Product with Serializable

case class CVP (guid: String, version: Long) extends CometVersionPair with Product with Serializable

trait CleanRequestVarOnSessionTransition extends AnyRef

trait CometActor extends BaseCometActor

abstract class CometActorJ extends LiftActorJ with CometActor

Subclass from this class if you're in Java-land and want a CometActor

abstract class CometActorJWithCometListener extends CometActorJ with CometListener

Subclass from this class if you want a CometActorJ with CometListeners

final case class CometCreationInfo (cometType: String, cometName: Box[String], cometHtml: NodeSeq, cometAttributes: Map[String, String], session: LiftSession) extends Product with Serializable

A case class that contains the information necessary to set up a CometActor

trait CometListener extends BaseCometActor

This trait adds functionality to automatically register with a given Actor using AddAListener and RemoveAListener control messages.

This trait adds functionality to automatically register with a given Actor using AddAListener and RemoveAListener control messages. The most typical usage would be to register with an instance of ListenerManager. You will need to provide a def/val for the

registerWith

member to control which Actor to connect to.

See ListenerManager for a complete example.

registerWith to control which Actor to connect to.

See ListenerManager for a complete example.

See also: ListenerManager

sealed abstract class CometMessage extends AnyRef

case class CometName (name: String) extends Product with Serializable

trait CometState [DeltaType <: DeltaTrait, MyType <: CometState[DeltaType, MyType]] extends AnyRef

trait CometStateWithUpdate [UpdateType, DeltaType <: DeltaTrait, MyType <: CometStateWithUpdate[UpdateType, DeltaType, MyType]] extends CometState[DeltaType, MyType]

trait CometVersionPair extends AnyRef

Holds the Comet identification information

trait ContainerSerializer [T] extends AnyRef

A trait that provides *actual* serialization of a type so that the type can be stored into a container's session and be migrated across servers

abstract class ContainerVar [T] extends util.AnyVar[T, ContainerVar[T]] with LazyLoggable

A typesafe container for data with a lifetime nominally equivalent to the lifetime of HttpSession attributes.

A typesafe container for data with a lifetime nominally equivalent to the lifetime of HttpSession attributes. This alternative to SessionVar keeps data in the container's session and must be serializable to support session migration. Use SessionVars unless you are using MigratoryLiftSessions.

object MySnippetCompanion { object mySessionVar extends ContainerVar[String]("hello") }

The standard pattern is to create a singleton object extending ContainerVar instead of creating an instance variable of a concrete ContainerVar subclass. This is preferred because ContainerVar will use the name of its instantiating class for part of its state maintenance mechanism.

If you find it necessary to create a ContainerVar subclass of which there may be more than one instance, it is necessary to override the nameSalt() method to return a unique salt value for each instance to prevent name collisions.

trait ContentParser extends AnyRef

Objects which can parse content should implement this trait.

Objects which can parse content should implement this trait. See LiftRules.contentParsers

Specifies a Content-Security-Policy for this site.

Specifies a Content-Security-Policy for this site. This will be sent to the client in a Content-Security-Policy header when responses are returned from Lift.

In development mode, content security policy violations are only reported if the browser supports them, not enforced. In all other modes, content security policy violations are enforced if the browser supports them.

Note that the X-Webkit-CSP header is NOT specified, due to potentially-broken behavior in iOS 5 and 5.1. This means iOS 6/6.1 will not receive a content security policy that it can understand. See the caniuse page on content security policy for more.

defaultSources: A list of default source restrictions; if one of the other sources parameters is empty, the default sources will apply instead.
connectSources: A list of source restrictions for XmlHttpRequest (AJAX) connections.
fontSources: A list of source restrictions for loading fonts (e.g., from CSS font-face declarations).
frameSources: A list of source restrictions for loading frames and iframes.
imageSources: A list of source restrictions for loading images.
mediaSources: A list of source restrictions for loading media (audio and video).
objectSources: A list of source restrictions for loading object, embed, applet, and related elements.
scriptSources: A list of source restrictions for loading scripts. Also accepts the UnsafeInline and UnsafeEval source restrictions, though these are strongly discouraged.
styleSources: A list of source restrictions for loading styles. Also accepts the UnsafeInline source, though it is strongly discouraged.
reportUri: The URI where any violation of the security policy will be reported. You can set the function that handles these violations in LiftRules.contentSecurityPolicyViolationReport. By default, reported to ContentSecurityPolicy.defaultReportUri. If this is None, violations will not be reported.

case class ContentSecurityPolicyViolation (documentUri: String, referrer: String, blockedUri: String, violatedDirective: String, originalPolicy: String) extends Product with Serializable

The expected payload of a content security policy violation report.

Parsable from the JSON POST that a browser should send when a violation occurs.

sealed trait ContentSourceRestriction extends AnyRef

Base trait for content source restrictions.

Base trait for content source restrictions. These are different ways of restricting where contents of various types are allowed to come from, in conjunction with ContentSecurityPolicy categories.

final case class ContentType (theType: String, subtype: String, order: Int, q: Box[Double], extension: List[(String, String)]) extends Ordered[ContentType] with Product with Serializable

Holds information about the content type and subtype including the q parameter and extension information.

class ContinueResponseException extends LiftFlowOfControlException

This exception is used by LiftSession.destroySessionAndContinueInNewSession to unwind the stack so that the session can be destroyed and a new session can be created and have the balance of the continuation executed in the context of the new session.

case class CreatedResponse (xml: Node, mime: String, addlHeaders: List[(String, String)] = XmlResponse.addlHeaders) extends XmlNodeResponse with Product with Serializable

201 Created Response

The Resource was created. We then return the resource, post-processing, to the client. Usually used with HTTP PUT.

sealed trait DataAttributeProcessorAnswer extends AnyRef

Sometimes we're going to have to surface more data from one of these requests than we might like (for example, extra info about continuing the computation on a different thread), so we'll start off right by having an Answer trait that will have some subclasses and implicit conversions

final case class DataAttributeProcessorAnswerFork (nodeFunc: () ⇒ NodeSeq) extends DataAttributeProcessorAnswer with Product with Serializable

A function that returns a bunch of nodes...

A function that returns a bunch of nodes... run it on a different thread

final case class DataAttributeProcessorAnswerFuture (nodeFuture: LAFuture[NodeSeq]) extends DataAttributeProcessorAnswer with Product with Serializable

A future that returns nodes...

A future that returns nodes... run them on a different thread

nodeFuture: the future of the NodeSeq

final case class DataAttributeProcessorAnswerNodes (nodes: NodeSeq) extends DataAttributeProcessorAnswer with Product with Serializable

Yep...

Yep... just a bunch of nodes.

abstract class Delta extends AnyRef

trait DeltaTrait extends AnyRef

trait DispatchSnippet extends AnyRef

case class Error (id: Box[String], msg: NodeSeq) extends CometMessage with Product with Serializable

trait Factory extends SimpleInjector

A base trait for a Factory.

A base trait for a Factory. A Factory is both an Injector and a collection of FactorMaker instances. The FactoryMaker instances auto-register with the Injector. This provides both concrete Maker/Vender functionality as well as Injector functionality.

case class FieldBinding (fieldName: String, bindingStyle: BindingStyle) extends Product with Serializable

abstract class FileParamHolder extends ParamHolder with Serializable

A FileParamHolder contains a file uploaded via a multipart form.

case class ForbiddenResponse (message: String) extends LiftResponse with HeaderDefaults with Product with Serializable

403 Forbidden

The server understood the request, but is refusing to fulfill it. Authorization will not help and the request SHOULD NOT be repeated.

trait FormVendor extends AnyRef

sealed trait FrameRestrictions extends AnyRef

Defines restrictions on allowing served pages to be embedded in frames.

class GUIDJsExp extends JsExp

A long time ago, Lift was going to track every function/GUID combination vended to a web page with extreme granularity.

A long time ago, Lift was going to track every function/GUID combination vended to a web page with extreme granularity. This meant that for every function/GUID vended, Lift would put that GUID in an attribute associated with the element on the page. In order to capture the GUIDs, some methods like SHtml.ajaxCall() returned a Tuple containing the GUID and the JsExp. This caused confusion and ugly code. So, the GUIDJsExp came into being. Basically, it's backward compatible with the Tuple (String, JsExp), but it functions like a JsExp (although you don't even have to call .toJsCmd because the toString method returns the expresion itself). It should make the ajaxCall()._2.toJsCmd thing into ajaxCall().

sealed trait GeneralSourceRestriction extends JavaScriptSourceRestriction with StylesheetSourceRestriction

abstract class GenericValidator extends XHtmlValidator with Loggable

case class GoneResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

410 Resource Gone

The requested Resource used to exist but no longer does.

final case class HandledRoundTrip [T](name: String, func: (T, RoundTripHandlerFunc) ⇒ Unit)(implicit manifest: Manifest[T]) extends RoundTripInfo with Product with Serializable

trait HeaderDefaults extends AnyRef

trait HowStateful extends AnyRef

A trait defining how stateful the session is

final case class Html5Properties (userAgent: Box[String]) extends HtmlProperties with Product with Serializable

If you're going to use HTML5, then this is the set of properties to use

trait HtmlProperties extends AnyRef

This trait encapsulates the various choices related to parsing and emitting HTML/XHTML

final case class HttpsRules (requiredTime: Option[Duration] = None, includeSubDomains: Boolean = false) extends Product with Serializable

Rules for HTTPS usage by a Lift application.

Currently corresponds directly to the HTTP Strict-Transport-Security header.

trait IdMemoizeTransform extends (NodeSeq) ⇒ NodeSeq

A mechanism to memoize a transformation and then re-use the most recent html and ID to redraw the content or even use an Ajax call to update the content

class InMemFileParamHolder extends FileParamHolder

This FileParamHolder stores the uploaded file directly into memory.

final case class InMemoryResponse (data: Array[Byte], headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends BasicResponse with Product with Serializable

trait InsecureLiftView extends AnyRef

If a class is to be used as a lift view (rendering from code rather than a static template) and the method names are to be used as "actions", the view must be marked as "InsecureLiftView" because there exists the ability to execute arbitrary methods based on wire content

trait IntField extends FieldIdentifier

case class InternalServerErrorResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

500 Internal Server Error

The server encountered an unexpected condition which prevented it from fulfilling the request.

case class JavaScriptResponse (js: JsCmd, headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends LiftResponse with Product with Serializable

Impersonates a HTTP response having Content-Type = text/javascript

sealed trait JavaScriptSourceRestriction extends ContentSourceRestriction

Marker trait for restrictions that only apply to JavaScript.

class JsContext extends AjaxContext

case class JsDelta (when: Long, js: JsCmd) extends Delta with Product with Serializable

class JsonContext extends AjaxContext

case class JsonResponse (json: JsExp, headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends LiftResponse with Product with Serializable

abstract class LiftActorJWithListenerManager extends LiftActorJ with ListenerManager

A LiftActorJ with ListenerManager.

A LiftActorJ with ListenerManager. Subclass this class to get a Java-usable LiftActorJ with ListenerManager

trait LiftCometActor extends TypedActor[Any, Any] with ForwardableActor[Any, Any] with Dependent

class LiftFilter extends ServletFilterProvider

trait LiftResponse extends AnyRef

class LiftRules extends Factory with FormVendor with LazyLoggable

LiftRules is the global object that holds all of Lift's configuration.

class LiftRulesGuardedSetting [T] extends LiftValue[T] with HasCalcDefaultValue[T]

This class encapsulates a mutable LiftRules setting which guards its value against changes which can produce unexpected results in a Lift application.

T: the type of the setting

class LiftRulesJ extends AnyRef

class LiftRulesJBridge extends AnyRef

sealed trait LiftRulesMocker extends AnyRef

trait LiftScreen extends AbstractScreen with StatefulSnippet with ScreenWizardRendered

class LiftServlet extends Loggable

class LiftSession extends LiftMerge with Loggable with HowStateful

The LiftSession class containing the session state information

trait LiftView extends AnyRef

The preferred way to do lift views...

The preferred way to do lift views... implement a partial function that dispatches the incoming request to an appropriate method

case class Listen (when: Long, uniqueId: ListenerId, action: (AnswerRender) ⇒ Unit) extends CometMessage with Product with Serializable

case class ListenerId (id: Long) extends Product with Serializable

trait ListenerManager extends AnyRef

This trait manages a set of Actors in a publish/subscribe pattern.

This trait manages a set of Actors in a publish/subscribe pattern. When you extend your Actor with this trait, you automatically get handling for sending messages out to all subscribed Actors. Simply override the high-, medium-, or lowPriority handlers to do your message processing. When you want to update all subscribers, just call the updateListeners method. The createUpdate method is used to generate the message that you want sent to all subscribers.

Note that the AddAListener and RemoveAListener messages (for subscription control) are processed after any highPriority or mediumPriority messages are processed, so take care to avoid overly broad matches in those handlers that might consume internal messages.

For example, you could write a simple service to provide clock ticks using the following code:

case object Tick

object Ticker extends ListenerManager with LiftActor {
  import net.liftweb.util.ActorPing

  // Set up the initial tick
  ActorPing.schedule(this, Tick, 1000L)

  // This is a placeholder, since we're only interested
  // in Ticks
  def createUpdate = "Registered"

  override def mediumPriority = {
    case Tick => {
      sendListenersMessage(Tick)
      ActorPing.schedule(this, Tick, 1000L)
}
}
}

A client CometActor could look like:

class CometClock extends CometListener {
  val registerWith = Ticker

  ... handling code ...
}

See also: CometListener

trait MVCHelper extends DispatchPF

Mix this trait into a class to provide support for MVC style coding.

Mix this trait into a class to provide support for MVC style coding. Each controller line is defined as:

serve {
  case "user" :: User(user) :: _ => "#name" #> user.firstName
}

The above code matches /user/4, loads the user with primary key 4 from the database, then applies the transform to the /user.html template replacing the node with the id "name" with the firstName of the user

trait MemoizeTransform extends (NodeSeq) ⇒ NodeSeq

Memoize the CSS Selector Transform and the most recent NodeSeq sent to the NodeSeq => NodeSeq so that when applyAgain() is called, the NodeSeq most recently used in apply() is used.

trait MessageCometActor extends BaseCometActor

class MessageState extends RedirectState

case class MethodNotAllowedResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

405 Method Not Allowed

This Resource does not allow this method. Use this when the resource can't understand the method no matter the circumstances.

trait MigratorySession extends HowStateful

Sessions that include this trait will only have access to the container's state via ContainerVars.

Sessions that include this trait will only have access to the container's state via ContainerVars. This mode is "migratory" so that a session can migrate across app servers. In this mode, functions that access Lift state will give notifications of failure if stateful features of Lift are accessed

trait NamedCometActorSnippet extends AnyRef

This trait adds a named comet actor on the page.

This trait adds a named comet actor on the page. *

trait NamedCometActorTrait extends BaseCometActor with Loggable

class NamedCometDispatcher extends LiftActor with Loggable

This class keeps a list of comet actors that need to update the UI

case class NoContentResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

204 response but without body.

trait NodeResponse extends LiftResponse

final case class NodeSeqFunc (f: (NodeSeq) ⇒ NodeSeq) extends NodeSeqFuncOrSeqNodeSeqFunc with Product with Serializable

sealed trait NodeSeqFuncOrSeqNodeSeqFunc extends (NodeSeq) ⇒ NodeSeq

case class NodesAndEventJs (nodes: NodeSeq, js: JsCmd) extends Product with Serializable

final case class NormalParamHolder (name: String, value: String) extends ParamHolder with Product with Serializable

case class NotAcceptableResponse (msg: String) extends LiftResponse with HeaderDefaults with Product with Serializable

406 Not Acceptable

This Resource does not allow this method. Use this when the resource can't understand the method no matter the circumstances.

sealed trait NotFound extends AnyRef

final case class NotFoundAsNode (node: NodeSeq) extends NotFound with Product with Serializable

final case class NotFoundAsResponse (response: LiftResponse) extends NotFound with Product with Serializable

final case class NotFoundAsTemplate (path: ParsePath) extends NotFound with Product with Serializable

case class NotFoundResponse (message: String) extends LiftResponse with HeaderDefaults with Product with Serializable

404 Not Found

The server has not found anything matching the Request-URI.

case class NotImplementedResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

501 Not Implemented

The server does not support the functionality required to fulfill the request. This is the appropriate response when the server does not recognize the request method and is not capable of supporting it for any resource.

case class Notice (id: Box[String], msg: NodeSeq) extends CometMessage with Product with Serializable

case class OkResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

200 response but without body.

final case class OldHtmlProperties (userAgent: Box[String]) extends HtmlProperties with Product with Serializable

This set of properties is based on Lift's current XHTML support

class OnDiskFileParamHolder extends FileParamHolder

This FileParamHolder stores the uploaded file in a temporary file on disk.

case class OpenSearchResponse (xml: Node, addlHeaders: List[(String, String)] = XmlResponse.addlHeaders) extends XmlNodeResponse with Product with Serializable

Returning an OpenSearch Description Document.

case class OutputStreamResponse (out: (OutputStream) ⇒ Unit, size: Long, headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends BasicResponse with Product with Serializable

Use this response to write your data directly to the response pipe.

Use this response to write your data directly to the response pipe. Along with StreamingResponse you have an alternative to send data to the client.

trait Paginator [T] extends Loggable

Base class for things that require pagination.

Base class for things that require pagination. Implements a contract for supplying the correct number of browsable pages etc

T: the type of item being paginated

trait PaginatorSnippet [T] extends Paginator[T]

This is the paginator snippet.

This is the paginator snippet. It provides page navigation and column sorting links.

The values for the pagination are bound according to the classes specified in the paginate method, using a CSS selector transform.

final case class ParamCalcInfo (paramNames: List[String], params: Map[String, List[String]], uploadedFiles: List[FileParamHolder], body: Box[BodyOrInputStream]) extends Product with Serializable

sealed trait ParamHolder extends Serializable

case class ParsePath (partPath: List[String], suffix: String, absolute: Boolean, endSlash: Boolean) extends Product with Serializable

The representation of an URI path

case class PartialUpdateMsg (cmd: () ⇒ JsCmd) extends CometMessage with Product with Serializable

case class PerformSetupComet2 (initialReq: Box[Req]) extends CometMessage with Product with Serializable

case class PermRedirectResponse (uri: String, request: Req, cookies: HTTPCookie*) extends LiftResponse with Product with Serializable

301 Redirect.

case class PlainTextResponse (text: String, headers: List[(String, String)], code: Int) extends LiftResponse with Product with Serializable

case class ReRender (doAll: Boolean) extends CometMessage with Product with Serializable

case class RedirectResponse (uri: String, request: Req, cookies: HTTPCookie*) extends LiftResponse with Product with Serializable

302

case class RedirectState (func: Box[() ⇒ Unit], msgs: (String, Value)*) extends Product with Serializable

class RedirectWithState extends RedirectResponse

case class RemoveAListener (who: SimpleActor[Any]) extends Product with Serializable

This is a message class for use with ListenerManager and CometListener instances.

See also: ListenerManager
CometListener

trait RenderDispatch extends AnyRef

Mix this into a StatefulSnippet if you want a defined render method.

trait RenderFuncDispatch extends AnyRef

Mix this into a StatefulSnippet if you want a defined render method.

Mix this into a StatefulSnippet if you want a defined render method. Differs from RenderDispatch because the render method returns a NodeSeq => NodeSeq

case class RenderOut (xhtml: Box[NodeSeq], fixedXhtml: Box[NodeSeq], script: Box[JsCmd], destroyScript: Box[JsCmd], ignoreHtmlOnJs: Boolean) extends Product with Serializable

The RenderOut case class contains the rendering for the CometActor.

The RenderOut case class contains the rendering for the CometActor. Because of the implicit conversions, RenderOut can come from

xhtml

is the "normal" render body

fixedXhtml

is the "fixed" part of the body. This is ignored unless reRender(true)

script

is the script to be executed on render. This is where you want to put your script

destroyScript

is executed when the comet widget is redrawn ( e.g., if you register drag or mouse-over or some events, you unregister them here so the page doesn't leak resources.)

ignoreHtmlOnJs

-- if the reason for sending the render is a Comet update, ignore the xhtml part and just run the JS commands. This is useful in IE when you need to redraw the stuff inside

is broken in IE

class Req extends HasParams with UserAgentCalculator

Contains request information

abstract class RequestMemoize [K, V] extends MemoizeVar[K, V]

Memoize a value for the duration of the current request (and subsequent Ajax requests made as a result of viewing the page)

abstract class RequestType extends Serializable

abstract class RequestVar [T] extends util.AnyVar[T, RequestVar[T]] with HasLogUnreadVal

A typesafe container for data with a lifetime nominally equivalent to the lifetime of a page rendered by an HTTP request.

A typesafe container for data with a lifetime nominally equivalent to the lifetime of a page rendered by an HTTP request. RequestVars maintain their value throughout the duration of the current HTTP request and any callbacks for servicing AJAX calls associated with the rendered page. RequestVar instances have no value at the beginning of request servicing (excluding AJAX callbacks) and their value is discarded at the end of request processing. They are commonly used to share values across many snippets. Basic usage:

object MySnippetCompanion { object myRequestVar extends RequestVar[String]("hello") }

The standard pattern is to create a singleton object extending RequestVar instead of creating an instance variable of a concrete RequestVar subclass. This is preferred because RequestVar will use the name of its instantiating class for part of its state maintenance mechanism.

If you find it necessary to create a RequestVar subclass of which there may be more than one instance, it is necessary to override the nameSalt() method to return a unique salt value for each instance to prevent name collisions.

trait RequestVarSnapshotGroup extends AnyRef

Create case objects that implement this trait and use the case objects to denote specific SnapshotGroups for RequestVars

case class ResetContentResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

205 response but without body.

final case class ResponseShortcutException (_response: () ⇒ LiftResponse, redirectTo: Box[String], doNotices: Boolean) extends LiftFlowOfControlException with Product with Serializable

case class ResponseWithReason (response: LiftResponse, reason: String) extends LiftResponse with Product with Serializable

Wraps a LiftResponse along with a HTTP reason-phrase.

Wraps a LiftResponse along with a HTTP reason-phrase. The reason-phrase will be set in the HTTP status line after the status code as per HTTP specifications.

response: - the response to be wrapped
reason: - the reason-phrase

final case class RewriteRequest (path: ParsePath, requestType: RequestType, httpRequest: HTTPRequest) extends Product with Serializable

This case class is used for pattern matching.

This case class is used for pattern matching. See LiftRules.statelessRewrite and LiftRules.statefulRewrite

final case class RewriteResponse (path: ParsePath, params: Map[String, String], stopRewriting: Boolean) extends Product with Serializable

trait RoundTripHandlerFunc extends AnyRef

A function (well, an interface with a bunch of methods on it) to call depending on the state of the round trip function.

sealed trait RoundTripInfo extends AnyRef

Stuff related to round trip messages

trait S extends HasParams with Loggable with UserAgentCalculator

An object representing the current state of the HTTP request and response.

An object representing the current state of the HTTP request and response. It uses the DynamicVariable construct such that each thread has its own local session info without passing a huge state construct around. The S object is initialized by LiftSession on request startup.

See also: LiftFilter
LiftSession

trait SHtml extends Loggable

The SHtml object defines a suite of XHTML element generator methods to simplify the creation of markup, particularly with forms and AJAX.

class SHtmlJ extends AnyRef

class SHtmlJBridge extends AnyRef

class SJ extends AnyRef

class SJBridge extends AnyRef

trait ScopedLiftActor extends LiftActor with LazyLoggable

A LiftActor that runs in the scope of the current Session, repleat with SessionVars, etc.

A LiftActor that runs in the scope of the current Session, repleat with SessionVars, etc. In general, you'll want to use a ScopedLiftActor when you do stuff with clientActorFor, etc. so that you have the session scope

case class ScreenFieldInfo (field: BaseField, text: NodeSeq, help: Box[NodeSeq], input: Box[NodeSeq], binding: Box[FieldBinding], transforms: List[(BaseField) ⇒ (NodeSeq) ⇒ NodeSeq]) extends Product with Serializable

trait ScreenWizardRendered extends Loggable

final case class SecurityRules (https: Option[HttpsRules] = None, content: Option[ContentSecurityPolicy] = Some(ContentSecurityPolicy()), frameRestrictions: Option[FrameRestrictions] = Some(FrameRestrictions.SameOrigin), enforceInOtherModes: Boolean = false, logInOtherModes: Boolean = true, enforceInDevMode: Boolean = false, logInDevMode: Boolean = true) extends Product with Serializable

Specifies security rules for a Lift application.

Specifies security rules for a Lift application. By default, HTTPS is not required and Content-Security-Policy is restricted to the current domain for everything except images, which are accepted from any domain. Additionally, served pages can only be embedded in other frames from the current domain.

You can use SecurityRules.secure to enable more restrictive, but also more secure, defaults.

enforceInDevMode: If true, security policies and HTTPS rules are enforced in dev mode in addition to staging/pilot/production/etc.
logInDevMode: If true, dev mode violations of security policies are logged by default. Note that if you override LiftRules.contentSecurityPolicyViolationReport or otherwise change the default Lift policy violation handling behavior, it will be up to you to handle this property as desired.

case class SeeOtherResponse (uri: String, request: Req, cookies: HTTPCookie*) extends LiftResponse with Product with Serializable

303

final case class SeqNodeSeqFunc (f: Seq[(NodeSeq) ⇒ NodeSeq]) extends NodeSeqFuncOrSeqNodeSeqFunc with Product with Serializable

case class ServiceUnavailableResponse (retryAfter: Long) extends LiftResponse with Product with Serializable

503 Bad Gateway

The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request.

case class SessionInfo (session: LiftSession, userAgent: Box[String], ipAddress: Box[String], requestCnt: Int, lastAccess: Long) extends Product with Serializable

Information about sessions

abstract class SessionMemoize [K, V] extends MemoizeVar[K, V]

Memoize a value for the duration of the user's session

abstract class SessionVar [T] extends util.AnyVar[T, SessionVar[T]] with LazyLoggable

A typesafe container for data with a lifetime nominally equivalent to the lifetime of HttpSession attributes.

object MySnippetCompanion { object mySessionVar extends SessionVar[String]("hello") }

The standard pattern is to create a singleton object extending SessionVar instead of creating an instance variable of a concrete SessionVar subclass. This is preferred because SessionVar will use the name of its instantiating class for part of its state maintenance mechanism.

If you find it necessary to create a SessionVar subclass of which there may be more than one instance, it is necessary to override the nameSalt() method to return a unique salt value for each instance to prevent name collisions.

Note: SessionVars can be used within CometActors

case class SessionWatcherInfo (sessions: Map[String, SessionInfo]) extends Product with Serializable

case class SetDeltaPruner (f: (LiftCometActor, List[Delta]) ⇒ List[Delta]) extends CometMessage with Product with Serializable

trait SimpleController extends AnyRef

The base trait of Controllers that handle pre-view requests

final case class SimpleRoundTrip [T](name: String, func: (T) ⇒ Any)(implicit manifest: Manifest[T]) extends RoundTripInfo with Product with Serializable

trait SimpleStateful extends StatefulSnippet with Whence with RenderFuncDispatch

The simple composition of StatefulSnippet, Whence and RenderFuncDispatch.

The simple composition of StatefulSnippet, Whence and RenderFuncDispatch. This is the common use of stateful snippets and makes things easier.

trait SimpleStatelessBehavior extends StatelessBehavior

A simpler way to define behavior if the snippet is invoked.

A simpler way to define behavior if the snippet is invoked. Just implement the stateless method and all methods for the snippet will use that behavior.

abstract class SnapshotRequestVar [T] extends RequestVar[T]

This subclass of RequestVars that allow the specification of a RequestVarSnapshotGroup.

This subclass of RequestVars that allow the specification of a RequestVarSnapshotGroup. You can create a snapshot of all the members of this group in RequestVar.snapshot

class SnippetExecutionException extends SnippetFailureException

Throw this exception if there's a catostrophic failure executing a snippet

abstract class SnippetFailureException extends LiftFlowOfControlException

An abstract exception that may be thrown during page rendering.

An abstract exception that may be thrown during page rendering. The exception is caught and the appropriate report of a SnippetError is generated

abstract class SnippetPFJ extends AnyRef

trait SnippetTimer extends AnyRef

A snippet timer is a general interface for timing snippets.

A snippet timer is a general interface for timing snippets. A few default implementations are provided and can be selected by setting LiftRules.snippetTimer as you need.

trait SortedPaginator [T, C] extends Paginator[T]

In many situations you'll want to sort things in your paginated view.

In many situations you'll want to sort things in your paginated view. SortedPaginator is a specialized paginator for doing such tasks.

T: The type of the elements, accessed via def page within the listing snippet C: The type of the columns, used to specify sorting

trait SortedPaginatorSnippet [T, C] extends SortedPaginator[T, C] with PaginatorSnippet[T]

This trait adds snippet functionality for sorted paginators.

This trait adds snippet functionality for sorted paginators. You can place bind points in your template for column headers, and it turns them into links That you can click to sort by that column. Simply write, e.g., <th><sort:name/></th><th><sort:email/></th> etc.

class StateInStatelessException extends SnippetFailureException

trait StatefulComet extends CometActor

trait StatefulSnippet extends DispatchSnippet

The same StatefulSnippet instance is used across a given page rendering.

The same StatefulSnippet instance is used across a given page rendering.
If the StatefulSnippet is used to render a form, a hidden field is added to the form that causes the same instance to be used on the page that is the target of the form submission.
If you want to keep the same snippet for a page rendered via a link (<a href...>) use the StatefulSnippet.link method to create the link. This will cause the registerThisSnippet method to be called and the same instance will be used on the target page.

class CountGame extends StatefulSnippet  {
 val dispatch: DispatchIt =  {
   case "run" => run _
}

 def run(xhtml: NodeSeq): NodeSeq =  {
   if (lastGuess == number)  {
     bind("count", chooseTemplate("choose", "win", xhtml), "number" --> number, "count" --> count)
} else  {
     bind("count", chooseTemplate("choose", "guess", xhtml),
       "input" --> text("", guess _),
       "last" --> lastGuess.map(v => if (v < number) v+" is low" else v+"is high").openOr("Make first Guess")
     )
}

 private def guess(in: String)  {
   count += 1
   lastGuess = Full(toInt(in))
}

 private val number = 1 + randomInt(100)
 private var lastGuess: Box[Int] = Empty
 private var count = 0

}

trait StatefulSortedPaginatorSnippet [T, C] extends SortedPaginatorSnippet[T, C]

Sort your paginated views by using lifts functions mapping.

Sort your paginated views by using lifts functions mapping. The only down side with this style is that your links are session specific and non-bookmarkable. If you mix this trait in to a StatefulSnippet, it should work out the box. Otherwise, implement 'registerThisSnippet.'

trait StatelessBehavior extends AnyRef

Mix this snippet into any snippet.

Mix this snippet into any snippet. If the snippet is invoked in response to a stateless request, then the behavior method is called with the method name of the snippet (usually render, but there may be others if you specify a method after the snippet name: MySnippet.dothing).

final case class StatelessReqTest (path: List[String], httpReq: HTTPRequest) extends Product with Serializable

The data structure that contains information to determine if the request should be treated as a stateful or stateless request

trait StatelessSession extends HowStateful

Sessions that include this trait will not be retained past the current request and will give notifications of failure if stateful features of Lift are accessed

final case class StreamRoundTrip [T](name: String, func: (T) ⇒ Stream[Any])(implicit manifest: Manifest[T]) extends RoundTripInfo with Product with Serializable

final case class StreamingResponse (data: AnyRef { def read(buf: Array[Byte]): Int }, onEnd: () ⇒ Unit, size: Long, headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends BasicResponse with Product with Serializable

trait StringField extends FieldIdentifier with StringValidators

sealed trait StylesheetSourceRestriction extends ContentSourceRestriction

Marker trait for restrictions that only apply to stylesheets.

case class TemporaryRedirectResponse (uri: String, request: Req, cookies: HTTPCookie*) extends LiftResponse with Product with Serializable

307 Redirect.

abstract class TransientRequestMemoize [K, V] extends MemoizeVar[K, V]

Memoize a value for the duration of the current HTTP request

abstract class TransientRequestVar [T] extends util.AnyVar[T, TransientRequestVar[T]] with HasLogUnreadVal

A typesafe container for data with a lifetime strictly equal to the processing of a single HTTP request.

A typesafe container for data with a lifetime strictly equal to the processing of a single HTTP request. Unlike ordinary RequestVar instances, TransientRequestVars will not maintain data for servicing of AJAX callbacks from a rendered page. This is useful in cases where the value stored within the RequestVar cannot safely be used across multiple requests; an example of such a value is a JTA UserTransaction which has a lifecycle strictly coupled to the actul HTTP request handling by the enclosing container.

trait TransientSnippet extends AnyRef

This trait indicates if the snippet instance should be kept around for the duration of the Request.

This trait indicates if the snippet instance should be kept around for the duration of the Request. There are cases when you don't want a snippet to be kept around.

class UnauthorizedDigestResponse extends UnauthorizedResponse

401 Unauthorized Response.

case class UnauthorizedResponse (realm: String) extends LiftResponse with Product with Serializable

401 Unauthorized Response.

case class UnknownRequest (method: String) extends RequestType with Product with Serializable

case class Unlisten (uniqueId: ListenerId) extends CometMessage with Product with Serializable

case class UnsupportedMediaTypeResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

415 Resource Gone

The requested Resource used to exist but no longer does.

case class UpdateDefaultHtml (html: NodeSeq) extends CometMessage with Product with Serializable

Update the comet XML on each page reload in dev mode

trait UserAgentCalculator extends AnyRef

class VarsJ extends AnyRef

class VarsJBridge extends AnyRef

The bridge between Scala *Vars implementations and the

case class Warning (id: Box[String], msg: NodeSeq) extends CometMessage with Product with Serializable

trait Whence extends AnyRef

Mix this trait into a snippet class so that you have a convenient value to redirect back to (whence).

Mix this trait into a snippet class so that you have a convenient value to redirect back to (whence). When you're done with the snippet, S.redirectTo(whence)

trait Wizard extends StatefulSnippet with Factory with ScreenWizardRendered

A wizard allows you to create a multi-screen set of input forms with back-button support and state support

case class XHTMLValidationError (msg: String, line: Int, col: Int) extends Product with Serializable

final case class XHtmlInHtml5OutProperties (userAgent: Box[String]) extends HtmlProperties with Product with Serializable

If you're going to use HTML5 out, but want XHTML in (so you can have mixed case snippet tags and you don't get the Html5 parsers obnoxious table behavior), then this is the set of properties to use

trait XHtmlValidator extends (Node) ⇒ List[XHTMLValidationError]

case class XhtmlResponse (out: Node, __docType: Box[String], _headers: List[(String, String)], cookies: List[HTTPCookie], code: Int, renderInIEMode: Boolean) extends NodeResponse with Product with Serializable

case class XmlMimeResponse (xml: Node, mime: String, addlHeaders: List[(String, String)] = XmlResponse.addlHeaders) extends XmlNodeResponse with Product with Serializable

Allows you to create custom 200 responses for clients using different Content-Types.

trait XmlNodeResponse extends LiftResponse

class XmlResponse extends XmlNodeResponse

case class registerCometActor (actor: BaseCometActor, name: Box[String]) extends Product with Serializable

These are the message we pass around to register each named comet actor with a dispatcher that only updates the specific version it monitors

case class unregisterCometActor (actor: BaseCometActor) extends Product with Serializable

Value Members

implicit def asyncResolvableTransform[ResolvableType, ResolvedType](implicit asyncResolveProvider: CanResolveAsync[ResolvableType, ResolvedType], innerTransform: CanBind[ResolvedType]): CanBind[ResolvableType]
Provides support for binding anything that has a CanResolveAsync implementation.
Provides support for binding anything that has a CanResolveAsync implementation. Out of the box, that's just Scala Futures and LAFutures, but it could just as easily be, for example, Twitter Futures if you're using Finagle; all you have to do is add a CanResolveAsync implicit for it.
object AddAListener extends Serializable
object AjaxContext extends Serializable
object AjaxType extends Enumeration
object AnyVar
object AppXmlResponse
object AskRender extends CometMessage with Product with Serializable
object BadResponse
object Bindings
A collection of types and implicit transformations used to allow composition of page elements based upon the types of rendered objects.
A collection of types and implicit transformations used to allow composition of page elements based upon the types of rendered objects.
In Lift, a "snippet" is a function from NodeSeq => NodeSeq, where the argument to the function is a template, and the result is a fragment of a page to be rendered. Of course, this is a bit of an abbreviation; the snippet function also has an argument which is the application state made available from S. A DataBinding[T] is very similar in this respect; it is a function from some piece of information of type T to a function from NodeSeq => NodeSeq. Since DataBinding is strongly typed with respect to the type of information being rendered, DataBinding instances are ideal for the rendering of objects that is used to build up snippets. For example:
```
import net.liftweb.http.Bindings._

case class MyClass(str: String, i: Int, other: MyOtherClass)
case class MyOtherClass(foo: String)

trait MyClassBinding extends DataBinding[MyClass] {
  implicit val otherBinding: DataBinding[MyOtherClass]

  override def apply(entity: MyClass) = (xhtml: NodeSeq) => {
    val otherTemplate = chooseTemplate("myclass", "other", xhtml)
    bind(
      "myclass", xhtml,
      "str" -> Text("#" + entity.str + "#"),
      "i" -> Text(entity.i.toString),
      "other" -> entity.other.bind(otherTemplate)
    )
  }

}

object myOtherClassBinding extends DataBinding[MyOtherClass] {
  override def apply(other: MyOtherClass) = (xhtml: NodeSeq) => {
    bind("other", xhtml, "foo" -> Text("%" + other.foo + "%"))
  }
}

object MyClassConcreteBinding extends MyClassBinding {
  override val otherBinding = myOtherClassBinding
}
```
In this example, two classes and their associated bindings are constructed; the first binding for MyClass is abstract, needing a specific instance of DataBinding[MyOtherClass] to enable the implicit conversion needed to render the contained MyOtherClass instance. A subtemplate is selected, and the call to other.bind both necessitates the implicit conversion to a Bindings.Binder instance and applies the appropriate formatting. You can see how this usage keeps the concerns of the view and the model nicely separated, while allowing composition over object graphs.
Please see the tests, as well as this blog post for additional details.
object CSSResponse extends Serializable
object ClearNotices extends CometMessage with Product with Serializable
object CometVersionPair
object ContainerSerializer
object ContentParser
object ContentSecurityPolicy extends Serializable
object ContentSecurityPolicyViolation extends LazyLoggable with Serializable
object ContentSourceRestriction
object ContentType extends Serializable
The ContentType companion object that has helper methods for parsing Accept headers and other things that contain multiple ContentType information.
object ContinueResponseException extends Serializable
object CreatedResponse extends Serializable
201 Created Response
201 Created Response
The Json Resource was created. We then return the resource, post-processing, to the client. Usually used with HTTP PUT.
object CurrentCometActor extends ThreadGlobal[LiftCometActor]
object CurrentHTTPReqResp extends ThreadGlobal[(HTTPRequest, HTTPResponse)]
A ThreadGlobal containing the low-level HTTPRequest and HTTPResponse instances Set very, very early.
object CurrentReq extends ThreadGlobal[Req]
A Thread-global containing the current Req.
A Thread-global containing the current Req. Set very, very early
object DataAttributeProcessorAnswer
The companion object that has the implicit conversions
object DefaultNotFound extends NotFound with Product with Serializable
object DefaultRoutines
Many routines in Lift can be customized in LiftRules, but have default behaviors.
Many routines in Lift can be customized in LiftRules, but have default behaviors. This singleton contains the default routines. **DO NOT** call these methods directly. Use LiftRules to call them. So, why make them public? So, we can document the default behaviors.
object DeleteRequest extends RequestType with Product with Serializable
object DoRedirectResponse
object DocType
Stock XHTML doctypes available to the lift programmer.
object Error extends Serializable
object FieldBinding extends Serializable
object FileParamHolder extends Serializable
object ForbiddenResponse extends Serializable
object FrameRestrictions
object FutureWithSession
object GUIDJsExp
The companion object for GUIDJsExp that does helpful implicit conversions.
object GetRequest extends RequestType with Product with Serializable
object HeadRequest extends RequestType with Product with Serializable
object Html5ElemAttr
object HttpsRules extends Serializable
object JavaScriptResponse extends Serializable
object JsonResponse extends Serializable
object LAFutureWithSession
object LiftRules extends LiftRulesMocker
The Lift configuration singleton
object LiftRulesGuardedSetting
object LiftRulesMocker
object LiftScreenRules extends Factory with FormVendor
object LiftSession
object ListenerManager
object LoggingSnippetTimer extends SnippetTimer
A SnippetTimer that logs its timings to the console.
object MessageState extends Serializable
object NamedCometListener extends Loggable
Maintain a Map[Value the actor monitors -> Ref to the Actor Dispatcher]
Maintain a Map[Value the actor monitors -> Ref to the Actor Dispatcher]
For a url like: http://hostnbame/index/?p=icecream If you name your actor based on the value of p For each flavor that users have on their urls, the map would be like: chocolate -> code.comet.CometClassNames@ea5e9e7 , vanilla -> code.comet.CometClassNames@wv9i7o3, etc
If we have the actor already on the Map, just return it, because it has to update the UI. If wee do not have this actor on our Map. create a new Dispatcher that will monitor this value, add it to our Map and return the Ref to this new dispatcher so it updates the UI
object NoOpSnippetTimer extends SnippetTimer
A SnippetTimer that does not do anything.
object NodeSeqFuncOrSeqNodeSeqFunc
object NotAcceptableResponse extends Serializable
object NotFoundResponse extends Serializable
object Notice extends Serializable
object NoticeType extends Serializable
Defines the notices types
object OnDiskFileParamHolder extends Serializable
object OptionsRequest extends RequestType with Product with Serializable
object OutputStreamResponse extends Serializable
object PageName extends RequestVar[String]
object PatchRequest extends RequestType with Product with Serializable
object PlainTextResponse extends Serializable
object PostRequest extends RequestType with Product with Serializable
object PutRequest extends RequestType with Product with Serializable
object Qop extends Enumeration
object RedirectResponse extends Serializable
Companion object to RedirectResponse
object RedirectState extends Serializable
object RedirectWithState extends Serializable
object Req
Helper object for constructing Req instances
object RequestType extends Serializable
object RequestVar
The companion object to RequestVars
object ResourceServer
object ResponseShortcutException extends Serializable
object RewriteResponse extends Serializable
Maintains the context of resolving the URL when cookies are disabled from container.
Maintains the context of resolving the URL when cookies are disabled from container. It maintains low coupling such as code within request processing is not aware of the actual response that encodes the URL.
object RoundTripInfo
The companion objects.
The companion objects. Has tasty implicits
object S extends S
An object representing the current state of the HTTP request and response.
An object representing the current state of the HTTP request and response. It uses the DynamicVariable construct such that each thread has its own local session info without passing a huge state construct around. The S object is initialized by LiftSession on request startup.

See also
LiftFilter
LiftSession
object SHtml extends SHtml
The SHtml object defines a suite of XHTML element generator methods to simplify the creation of markup, particularly with forms and AJAX.
object ScreenFieldInfo extends Serializable
object SecurityRules extends Serializable
object SeeOtherResponse extends Serializable
Companion object to RedirectResponse
object SessionMaster extends LiftActor with Loggable
Manages LiftSessions because the servlet container is less than optimal at timing sessions out.
object ShutDown extends Product with Serializable
The response from a page saying that it's been rendered
object ShutdownIfPastLifespan extends CometMessage with Product with Serializable
object StrictXHTML1_0Validator extends GenericValidator
object Templates
Contains functions for obtaining templates
object TransientSnippet
The companion object to the TransientSnippet trait
object TransitionalXHTML1_0Validator extends GenericValidator
object URLRewriter
Provides access to a thread-local URL rewriter.
Provides access to a thread-local URL rewriter. Typically uses either an applicable entry in LiftRules.urlDecorate or the container's built-in URL decoration which may append the session id to the URL (dependent on LiftRules.encodeJSessionIdInUrl_?).
object UnauthorizedDigestResponse extends Serializable
Companion object with builder
object UserAgentCalculator extends Factory
object Warning extends Serializable
object WiringUI
Surface a user interface on top of Wiring
object WizardRules extends Factory with FormVendor
object XmlResponse

Inherited from AnyRef

Inherited from Any

Ungrouped

... just doing innerHtml on

Packages

http

package http

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

http 

package http

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

http