Packages

package http

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

Type Members

  1. trait AbstractScreen extends Factory with Loggable

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

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

    202 response but without body.

  3. case class ActionMessageSet (msg: List[() ⇒ Any], req: Req) extends CometMessage with Product with Serializable
  4. 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

  5. case class AjaxContext (success: Box[String], failure: Box[String], responseType: AjaxType.Value) extends Product with Serializable
  6. case class AnswerQuestion (what: Any, listeners: List[(ListenerId, (AnswerRender) ⇒ Unit)]) extends CometMessage with Product with Serializable
  7. case class AnswerRender (response: XmlOrJsCmd, who: LiftCometActor, when: Long, displayAll: Boolean) extends CometMessage with Product with Serializable
  8. case class AskQuestion (what: Any, who: LiftCometActor, listeners: List[(ListenerId, (AnswerRender) ⇒ Unit)]) extends CometMessage with Product with Serializable
  9. case class AtomCategoryResponse (xml: Node) extends LiftResponse with Product with Serializable

    Returning an Atom category document.

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

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

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

    Returning an Atom document.

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

    Returning an Atom Service Document.

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

    502 Bad Gateway

    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.

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

    400 Bad Request

    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.

  15. trait BaseCometActor extends LiftActor with LiftCometActor with CssBindImplicits

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

  16. sealed trait BasicResponse extends LiftResponse
  17. trait BlankStatelessBehavior extends StatelessBehavior

    A "default" implementation of StatelessBehavior.

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

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

  19. trait BooleanField extends FieldIdentifier
  20. abstract class Bootable extends AnyRef
  21. final case class BreakOut () extends Product with Serializable
  22. case class CSSResponse (text: String, headers: List[(String, String)], code: Int) extends LiftResponse with Product with Serializable
  23. case class CVP (guid: String, version: Long) extends CometVersionPair with Product with Serializable
  24. trait CleanRequestVarOnSessionTransition extends AnyRef
  25. trait CometActor extends BaseCometActor
  26. abstract class CometActorJ extends LiftActorJ with CometActor

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

  27. abstract class CometActorJWithCometListener extends CometActorJ with CometListener

    Subclass from this class if you want a CometActorJ with CometListeners

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

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

  30. sealed abstract class CometMessage extends AnyRef
  31. case class CometName (name: String) extends Product with Serializable
  32. trait CometState [DeltaType <: DeltaTrait, MyType <: CometState[DeltaType, MyType]] extends AnyRef
  33. trait CometStateWithUpdate [UpdateType, DeltaType <: DeltaTrait, MyType <: CometStateWithUpdate[UpdateType, DeltaType, MyType]] extends CometState[DeltaType, MyType]
  34. trait CometVersionPair extends AnyRef

    Holds the Comet identification information

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

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

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

  38. final case class ContentSecurityPolicy (defaultSources: List[ContentSourceRestriction] = List(ContentSourceRestriction.Self), connectSources: List[ContentSourceRestriction] = Nil, fontSources: List[ContentSourceRestriction] = Nil, frameSources: List[ContentSourceRestriction] = Nil, imageSources: List[ContentSourceRestriction] = List(ContentSourceRestriction.All), mediaSources: List[ContentSourceRestriction] = Nil, objectSources: List[ContentSourceRestriction] = Nil, scriptSources: List[JavaScriptSourceRestriction] = ..., styleSources: List[StylesheetSourceRestriction] = Nil, reportUri: Option[URI] = ...) extends Product with Serializable

    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.

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

    The expected payload of a content security policy violation report.

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

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

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

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

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

    201 Created Response

    201 Created Response

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

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

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

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

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

    Yep...

    Yep... just a bunch of nodes.

  48. abstract class Delta extends AnyRef
  49. trait DeltaTrait extends AnyRef
  50. trait DispatchSnippet extends AnyRef
  51. case class Error (id: Box[String], msg: NodeSeq) extends CometMessage with Product with Serializable
  52. 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.

  53. case class FieldBinding (fieldName: String, bindingStyle: BindingStyle) extends Product with Serializable
  54. abstract class FileParamHolder extends ParamHolder with Serializable

    A FileParamHolder contains a file uploaded via a multipart form.

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

    403 Forbidden

    403 Forbidden

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

  56. trait FormVendor extends AnyRef
  57. sealed trait FrameRestrictions extends AnyRef

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

  58. 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().

  59. sealed trait GeneralSourceRestriction extends JavaScriptSourceRestriction with StylesheetSourceRestriction
  60. abstract class GenericValidator extends XHtmlValidator with Loggable
  61. case class GoneResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

    410 Resource Gone

    410 Resource Gone

    The requested Resource used to exist but no longer does.

  62. final case class HandledRoundTrip [T](name: String, func: (T, RoundTripHandlerFunc) ⇒ Unit)(implicit manifest: Manifest[T]) extends RoundTripInfo with Product with Serializable
  63. trait HeaderDefaults extends AnyRef
  64. trait HowStateful extends AnyRef

    A trait defining how stateful the session is

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

  66. trait HtmlProperties extends AnyRef

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

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

    Rules for HTTPS usage by a Lift application.

    Rules for HTTPS usage by a Lift application.

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

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

  69. class InMemFileParamHolder extends FileParamHolder

    This FileParamHolder stores the uploaded file directly into memory.

  70. final case class InMemoryResponse (data: Array[Byte], headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends BasicResponse with Product with Serializable
  71. 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

  72. trait IntField extends FieldIdentifier
  73. case class InternalServerErrorResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

    500 Internal Server Error

    500 Internal Server Error

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

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

  75. sealed trait JavaScriptSourceRestriction extends ContentSourceRestriction

    Marker trait for restrictions that only apply to JavaScript.

  76. class JsContext extends AjaxContext
  77. case class JsDelta (when: Long, js: JsCmd) extends Delta with Product with Serializable
  78. class JsonContext extends AjaxContext
  79. case class JsonResponse (json: JsExp, headers: List[(String, String)], cookies: List[HTTPCookie], code: Int) extends LiftResponse with Product with Serializable
  80. 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

  81. trait LiftCometActor extends TypedActor[Any, Any] with ForwardableActor[Any, Any] with Dependent
  82. class LiftFilter extends ServletFilterProvider
  83. trait LiftResponse extends AnyRef
  84. class LiftRules extends Factory with FormVendor with LazyLoggable

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

  85. class LiftRulesJ extends AnyRef
  86. class LiftRulesJBridge extends AnyRef
  87. sealed trait LiftRulesMocker extends AnyRef
  88. trait LiftScreen extends AbstractScreen with StatefulSnippet with ScreenWizardRendered
  89. class LiftServlet extends Loggable
  90. class LiftSession extends LiftMerge with Loggable with HowStateful

    The LiftSession class containing the session state information

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

  92. case class Listen (when: Long, uniqueId: ListenerId, action: (AnswerRender) ⇒ Unit) extends CometMessage with Product with Serializable
  93. case class ListenerId (id: Long) extends Product with Serializable
  94. 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

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

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

  97. trait MessageCometActor extends BaseCometActor
  98. class MessageState extends RedirectState
  99. case class MethodNotAllowedResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

    405 Method Not Allowed

    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.

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

  101. trait NamedCometActorSnippet extends AnyRef

    This trait adds a named comet actor on the page.

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

  102. trait NamedCometActorTrait extends BaseCometActor with Loggable
  103. class NamedCometDispatcher extends LiftActor with Loggable

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

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

    204 response but without body.

  105. trait NodeResponse extends LiftResponse
  106. final case class NodeSeqFunc (f: (NodeSeq) ⇒ NodeSeq) extends NodeSeqFuncOrSeqNodeSeqFunc with Product with Serializable
  107. sealed trait NodeSeqFuncOrSeqNodeSeqFunc extends (NodeSeq) ⇒ NodeSeq
  108. case class NodesAndEventJs (nodes: NodeSeq, js: JsCmd) extends Product with Serializable
  109. final case class NormalParamHolder (name: String, value: String) extends ParamHolder with Product with Serializable
  110. case class NotAcceptableResponse (msg: String) extends LiftResponse with HeaderDefaults with Product with Serializable

    406 Not Acceptable

    406 Not Acceptable

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

  111. sealed trait NotFound extends AnyRef
  112. final case class NotFoundAsNode (node: NodeSeq) extends NotFound with Product with Serializable
  113. final case class NotFoundAsResponse (response: LiftResponse) extends NotFound with Product with Serializable
  114. final case class NotFoundAsTemplate (path: ParsePath) extends NotFound with Product with Serializable
  115. case class NotFoundResponse (message: String) extends LiftResponse with HeaderDefaults with Product with Serializable

    404 Not Found

    404 Not Found

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

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

    501 Not Implemented

    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.

  117. case class Notice (id: Box[String], msg: NodeSeq) extends CometMessage with Product with Serializable
  118. case class OkResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

    200 response but without body.

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

  120. class OnDiskFileParamHolder extends FileParamHolder

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

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

    Returning an OpenSearch Description Document.

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

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

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

  125. final case class ParamCalcInfo (paramNames: List[String], params: Map[String, List[String]], uploadedFiles: List[FileParamHolder], body: Box[BodyOrInputStream]) extends Product with Serializable
  126. sealed trait ParamHolder extends Serializable
  127. case class ParsePath (partPath: List[String], suffix: String, absolute: Boolean, endSlash: Boolean) extends Product with Serializable

    The representation of an URI path

  128. case class PartialUpdateMsg (cmd: () ⇒ JsCmd) extends CometMessage with Product with Serializable
  129. case class PerformSetupComet2 (initialReq: Box[Req]) extends CometMessage with Product with Serializable
  130. case class PermRedirectResponse (uri: String, request: Req, cookies: HTTPCookie*) extends LiftResponse with Product with Serializable

    301 Redirect.

  131. case class PlainTextResponse (text: String, headers: List[(String, String)], code: Int) extends LiftResponse with Product with Serializable
  132. case class ReRender (doAll: Boolean) extends CometMessage with Product with Serializable
  133. case class RedirectResponse (uri: String, request: Req, cookies: HTTPCookie*) extends LiftResponse with Product with Serializable

    302

  134. case class RedirectState (func: Box[() ⇒ Unit], msgs: (String, Value)*) extends Product with Serializable
  135. class RedirectWithState extends RedirectResponse
  136. case class RemoveAListener (who: SimpleActor[Any]) 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.

    See also

    ListenerManager

    CometListener

  137. trait RenderDispatch extends AnyRef

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

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

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

  140. class Req extends HasParams with UserAgentCalculator

    Contains request information

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

  142. abstract class RequestType extends Serializable
  143. 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.

  144. trait RequestVarSnapshotGroup extends AnyRef

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

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

    205 response but without body.

  146. final case class ResponseShortcutException (_response: () ⇒ LiftResponse, redirectTo: Box[String], doNotices: Boolean) extends LiftFlowOfControlException with Product with Serializable
  147. 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

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

  149. final case class RewriteResponse (path: ParsePath, params: Map[String, String], stopRewriting: Boolean) extends Product with Serializable
  150. 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.

  151. sealed trait RoundTripInfo extends AnyRef

    Stuff related to round trip messages

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

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

  154. class SHtmlJ extends AnyRef
  155. class SHtmlJBridge extends AnyRef
  156. class SJ extends AnyRef
  157. class SJBridge extends AnyRef
  158. 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

  159. 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
  160. trait ScreenWizardRendered extends Loggable
  161. 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.

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

    303

  163. final case class SeqNodeSeqFunc (f: Seq[(NodeSeq) ⇒ NodeSeq]) extends NodeSeqFuncOrSeqNodeSeqFunc with Product with Serializable
  164. case class ServiceUnavailableResponse (retryAfter: Long) extends LiftResponse with Product with Serializable

    503 Bad Gateway

    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.

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

    Information about sessions

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

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

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

    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

  168. case class SessionWatcherInfo (sessions: Map[String, SessionInfo]) extends Product with Serializable
  169. case class SetDeltaPruner (f: (LiftCometActor, List[Delta]) ⇒ List[Delta]) extends CometMessage with Product with Serializable
  170. trait SimpleController extends AnyRef

    The base trait of Controllers that handle pre-view requests

  171. final case class SimpleRoundTrip [T](name: String, func: (T) ⇒ Any)(implicit manifest: Manifest[T]) extends RoundTripInfo with Product with Serializable
  172. 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.

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

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

  175. class SnippetExecutionException extends SnippetFailureException

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

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

  177. abstract class SnippetPFJ extends AnyRef
  178. 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

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

  180. class StateInStatelessException extends SnippetFailureException
  181. trait StatefulComet extends CometActor
  182. 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
    
    }
    

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

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

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

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

  187. final case class StreamRoundTrip [T](name: String, func: (T) ⇒ Stream[Any])(implicit manifest: Manifest[T]) extends RoundTripInfo with Product with Serializable
  188. 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
  189. trait StringField extends FieldIdentifier with StringValidators
  190. sealed trait StylesheetSourceRestriction extends ContentSourceRestriction

    Marker trait for restrictions that only apply to stylesheets.

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

    307 Redirect.

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

    Memoize a value for the duration of the current HTTP request

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

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

  195. class UnauthorizedDigestResponse extends UnauthorizedResponse

    401 Unauthorized Response.

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

    401 Unauthorized Response.

  197. case class UnknownRequest (method: String) extends RequestType with Product with Serializable
  198. case class Unlisten (uniqueId: ListenerId) extends CometMessage with Product with Serializable
  199. case class UnsupportedMediaTypeResponse () extends LiftResponse with HeaderDefaults with Product with Serializable

    415 Resource Gone

    415 Resource Gone

    The requested Resource used to exist but no longer does.

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

    Update the comet XML on each page reload in dev mode

  201. trait UserAgentCalculator extends AnyRef
  202. class VarsJ extends AnyRef
  203. class VarsJBridge extends AnyRef

    The bridge between Scala *Vars implementations and the

  204. case class Warning (id: Box[String], msg: NodeSeq) extends CometMessage with Product with Serializable
  205. 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)

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

  207. case class XHTMLValidationError (msg: String, line: Int, col: Int) extends Product with Serializable
  208. 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

  209. trait XHtmlValidator extends (Node) ⇒ List[XHTMLValidationError]
  210. 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
  211. 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.

  212. trait XmlNodeResponse extends LiftResponse
  213. class XmlResponse extends XmlNodeResponse
  214. 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

  215. case class unregisterCometActor (actor: BaseCometActor) extends Product with Serializable
  216. Value Members

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

    2. object AddAListener extends Serializable
    3. object AjaxContext extends Serializable
    4. object AjaxType extends Enumeration
    5. object AnyVar
    6. object AppXmlResponse
    7. object AskRender extends CometMessage with Product with Serializable
    8. object BadResponse
    9. 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.

    10. object CSSResponse extends Serializable
    11. object ClearNotices extends CometMessage with Product with Serializable
    12. object CometVersionPair
    13. object ContainerSerializer
    14. object ContentParser
    15. object ContentSecurityPolicy extends Serializable
    16. object ContentSecurityPolicyViolation extends LazyLoggable with Serializable
    17. object ContentSourceRestriction
    18. object ContentType extends Serializable

      The ContentType companion object that has helper methods for parsing Accept headers and other things that contain multiple ContentType information.

    19. object ContinueResponseException extends Serializable
    20. 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.

    21. object CurrentCometActor extends ThreadGlobal[LiftCometActor]
    22. object CurrentHTTPReqResp extends ThreadGlobal[(HTTPRequest, HTTPResponse)]

      A ThreadGlobal containing the low-level HTTPRequest and HTTPResponse instances Set very, very early.

    23. object CurrentReq extends ThreadGlobal[Req]

      A Thread-global containing the current Req.

      A Thread-global containing the current Req. Set very, very early

    24. object DataAttributeProcessorAnswer

      The companion object that has the implicit conversions

    25. object DefaultNotFound extends NotFound with Product with Serializable
    26. 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.

    27. object DeleteRequest extends RequestType with Product with Serializable
    28. object DoRedirectResponse
    29. object DocType

      Stock XHTML doctypes available to the lift programmer.

    30. object Error extends Serializable
    31. object FieldBinding extends Serializable
    32. object FileParamHolder extends Serializable
    33. object ForbiddenResponse extends Serializable
    34. object FrameRestrictions
    35. object FutureWithSession
    36. object GUIDJsExp

      The companion object for GUIDJsExp that does helpful implicit conversions.

    37. object GetRequest extends RequestType with Product with Serializable
    38. object HeadRequest extends RequestType with Product with Serializable
    39. object Html5ElemAttr
    40. object HttpsRules extends Serializable
    41. object JavaScriptResponse extends Serializable
    42. object JsonResponse extends Serializable
    43. object LAFutureWithSession
    44. object LiftRules extends LiftRulesMocker

      The Lift configuration singleton

    45. object LiftRulesMocker
    46. object LiftScreenRules extends Factory with FormVendor
    47. object LiftSession
    48. object ListenerManager
    49. object MessageState extends Serializable
    50. 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

    51. object NodeSeqFuncOrSeqNodeSeqFunc
    52. object NotAcceptableResponse extends Serializable
    53. object NotFoundResponse extends Serializable
    54. object Notice extends Serializable
    55. object NoticeType extends Serializable

      Defines the notices types

    56. object OnDiskFileParamHolder extends Serializable
    57. object OptionsRequest extends RequestType with Product with Serializable
    58. object OutputStreamResponse extends Serializable
    59. object PageName extends RequestVar[String]
    60. object PlainTextResponse extends Serializable
    61. object PostRequest extends RequestType with Product with Serializable
    62. object PutRequest extends RequestType with Product with Serializable
    63. object Qop extends Enumeration
    64. object RedirectResponse extends Serializable

      Companion object to RedirectResponse

    65. object RedirectState extends Serializable
    66. object RedirectWithState extends Serializable
    67. object Req

      Helper object for constructing Req instances

    68. object RequestType extends Serializable
    69. object RequestVar

      The companion object to RequestVars

    70. object ResourceServer
    71. object ResponseShortcutException extends Serializable
    72. 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.

    73. object RoundTripInfo

      The companion objects.

      The companion objects. Has tasty implicits

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

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

    76. object ScreenFieldInfo extends Serializable
    77. object SecurityRules extends Serializable
    78. object SeeOtherResponse extends Serializable

      Companion object to RedirectResponse

    79. object SessionMaster extends LiftActor with Loggable

      Manages LiftSessions because the servlet container is less than optimal at timing sessions out.

    80. object ShutDown extends Product with Serializable

      The response from a page saying that it's been rendered

    81. object ShutdownIfPastLifespan extends CometMessage with Product with Serializable
    82. object StrictXHTML1_0Validator extends GenericValidator
    83. object Templates

      Contains functions for obtaining templates

    84. object TransientSnippet

      The companion object to the TransientSnippet trait

    85. object TransitionalXHTML1_0Validator extends GenericValidator
    86. 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_?).

    87. object UnauthorizedDigestResponse extends Serializable

      Companion object with builder

    88. object UserAgentCalculator extends Factory
    89. object Warning extends Serializable
    90. object WiringUI

      Surface a user interface on top of Wiring

    91. object WizardRules extends Factory with FormVendor
    92. object XmlResponse

    Inherited from AnyRef

    Inherited from Any

    Ungrouped

    ... just doing innerHtml on