Package

net.liftweb

http

Permalink

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

    Permalink

    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

    Permalink

    202 response but without body.

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

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

    Permalink

    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

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

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

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

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

    Permalink

    Returning an Atom category document.

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

    Permalink

    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

    Permalink

    Returning an Atom document.

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

    Permalink

    Returning an Atom Service Document.

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

    Permalink

    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

    Permalink

    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

    Permalink

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

  16. sealed trait BasicResponse extends LiftResponse

    Permalink
  17. trait BlankStatelessBehavior extends StatelessBehavior

    Permalink

    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

    Permalink

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

  19. trait BooleanField extends FieldIdentifier

    Permalink
  20. abstract class Bootable extends AnyRef

    Permalink
  21. final case class BreakOut() extends Product with Serializable

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

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

    Permalink
  24. trait CleanRequestVarOnSessionTransition extends AnyRef

    Permalink
  25. trait CometActor extends BaseCometActor

    Permalink
  26. abstract class CometActorJ extends LiftActorJ with CometActor

    Permalink

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

  27. abstract class CometActorJWithCometListener extends CometActorJ with CometListener

    Permalink

    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

    Permalink

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

  29. trait CometListener extends BaseCometActor

    Permalink

    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

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

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

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

    Permalink
  34. trait CometVersionPair extends AnyRef

    Permalink

    Holds the Comet identification information

  35. trait ContainerSerializer[T] extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

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

  42. class ContinueResponseException extends LiftFlowOfControlException

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    Yep...

    Yep... just a bunch of nodes.

  48. abstract class Delta extends AnyRef

    Permalink
  49. trait DeltaTrait extends AnyRef

    Permalink
  50. trait DispatchSnippet extends AnyRef

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

    Permalink
  52. trait Factory extends SimpleInjector

    Permalink

    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

    Permalink
  54. abstract class FileParamHolder extends ParamHolder with Serializable

    Permalink

    A FileParamHolder contains a file uploaded via a multipart form.

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

    Permalink

    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

    Permalink
  57. sealed trait FrameRestrictions extends AnyRef

    Permalink

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

  58. class GUIDJsExp extends JsExp

    Permalink

    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

    Permalink
  60. abstract class GenericValidator extends XHtmlValidator with Loggable

    Permalink
  61. case class GoneResponse() extends LiftResponse with HeaderDefaults with Product with Serializable

    Permalink

    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

    Permalink
  63. trait HeaderDefaults extends AnyRef

    Permalink
  64. trait HowStateful extends AnyRef

    Permalink

    A trait defining how stateful the session is

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

    Permalink

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

  66. trait HtmlProperties extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
  71. trait InsecureLiftView extends AnyRef

    Permalink

    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

    Permalink
  73. case class InternalServerErrorResponse() extends LiftResponse with HeaderDefaults with Product with Serializable

    Permalink

    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

    Permalink

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

  75. sealed trait JavaScriptSourceRestriction extends ContentSourceRestriction

    Permalink

    Marker trait for restrictions that only apply to JavaScript.

  76. class JsContext extends AjaxContext

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

    Permalink
  78. class JsonContext extends AjaxContext

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

    Permalink
  80. abstract class LiftActorJWithListenerManager extends LiftActorJ with ListenerManager

    Permalink

    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

    Permalink
  82. class LiftFilter extends ServletFilterProvider

    Permalink
  83. trait LiftResponse extends AnyRef

    Permalink
  84. class LiftRules extends Factory with FormVendor with LazyLoggable

    Permalink

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

  85. class LiftRulesJ extends AnyRef

    Permalink
  86. class LiftRulesJBridge extends AnyRef

    Permalink
  87. sealed trait LiftRulesMocker extends AnyRef

    Permalink
  88. trait LiftScreen extends AbstractScreen with StatefulSnippet with ScreenWizardRendered

    Permalink
  89. class LiftServlet extends Loggable

    Permalink
  90. class LiftSession extends LiftMerge with Loggable with HowStateful

    Permalink

    The LiftSession class containing the session state information

  91. trait LiftView extends AnyRef

    Permalink

    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

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

    Permalink
  94. trait ListenerManager extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
  98. class MessageState extends RedirectState

    Permalink
  99. case class MethodNotAllowedResponse() extends LiftResponse with HeaderDefaults with Product with Serializable

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
  103. class NamedCometDispatcher extends LiftActor with Loggable

    Permalink

    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

    Permalink

    204 response but without body.

  105. trait NodeResponse extends LiftResponse

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

    Permalink
  107. sealed trait NodeSeqFuncOrSeqNodeSeqFunc extends (NodeSeq) ⇒ NodeSeq

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

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

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

    Permalink

    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

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

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

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

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

    Permalink

    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

    Permalink

    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

    Permalink
  118. case class OkResponse() extends LiftResponse with HeaderDefaults with Product with Serializable

    Permalink

    200 response but without body.

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

    Permalink

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

  120. class OnDiskFileParamHolder extends FileParamHolder

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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]

    Permalink

    This is the paginator snippet.

    This is the paginator snippet. It provides page navigation and column sorting links. View XHTML is as follows: nav prefix (prefix is configurable by overriding def navPrefix)

    • <nav:first/> - a link to the first page
    • <nav:prev/> - a link to the previous page
    • <nav:allpages/> - individual links to all pages. The contents of this node are used to separate page links.
    • <nav:next/> - a link to the next page
    • <nav:last/> - a link to the last page
    • <nav:records/> - a description of which records are currently being displayed
    • <nav:recordsFrom/> - the first record number being displayed
    • <nav:recordsTo/> - the last record number being displayed
    • <nav:recordsCount/> - the total number of records on all pages
  125. final case class ParamCalcInfo(paramNames: List[String], params: Map[String, List[String]], uploadedFiles: List[FileParamHolder], body: Box[BodyOrInputStream]) extends Product with Serializable

    Permalink
  126. sealed trait ParamHolder extends Serializable

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

    Permalink

    The representation of an URI path

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

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

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

    Permalink

    301 Redirect.

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

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

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

    Permalink

    302

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

    Permalink
  135. class RedirectWithState extends RedirectResponse

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

    Permalink

    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

    Permalink

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

  138. trait RenderFuncDispatch extends AnyRef

    Permalink

    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

    Permalink

    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

    Permalink

    Contains request information

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

    Permalink

    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

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

    Permalink

    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

    Permalink

    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

    Permalink

    205 response but without body.

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

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

    Permalink

    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

    Permalink

    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

    Permalink
  150. trait RoundTripHandlerFunc extends AnyRef

    Permalink

    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

    Permalink

    Stuff related to round trip messages

  152. trait S extends HasParams with Loggable with UserAgentCalculator

    Permalink

    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

    Permalink

    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

    Permalink
  155. class SHtmlJBridge extends AnyRef

    Permalink
  156. class SJ extends AnyRef

    Permalink
  157. class SJBridge extends AnyRef

    Permalink
  158. trait ScopedLiftActor extends LiftActor with LazyLoggable

    Permalink

    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

    Permalink
  160. trait ScreenWizardRendered extends Loggable

    Permalink
  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

    Permalink

    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

    Permalink

    303

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

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

    Permalink

    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

    Permalink

    Information about sessions

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

    Permalink

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

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

    Permalink

    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

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

    Permalink
  170. trait SimpleController extends AnyRef

    Permalink

    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

    Permalink
  172. trait SimpleStateful extends StatefulSnippet with Whence with RenderFuncDispatch

    Permalink

    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

    Permalink

    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]

    Permalink

    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

    Permalink

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

  176. abstract class SnippetFailureException extends LiftFlowOfControlException

    Permalink

    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

    Permalink
  178. trait SortedPaginator[T, C] extends Paginator[T]

    Permalink

    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]

    Permalink

    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

    Permalink
  181. trait StatefulComet extends CometActor

    Permalink
  182. trait StatefulSnippet extends DispatchSnippet

    Permalink

    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]

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink
  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

    Permalink
  189. trait StringField extends FieldIdentifier with StringValidators

    Permalink
  190. sealed trait StylesheetSourceRestriction extends ContentSourceRestriction

    Permalink

    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

    Permalink

    307 Redirect.

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

    Permalink

    Memoize a value for the duration of the current HTTP request

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

    Permalink

    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

    Permalink

    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

    Permalink

    401 Unauthorized Response.

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

    Permalink

    401 Unauthorized Response.

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

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

    Permalink
  199. case class UnsupportedMediaTypeResponse() extends LiftResponse with HeaderDefaults with Product with Serializable

    Permalink

    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

    Permalink

    Update the comet XML on each page reload in dev mode

  201. trait UserAgentCalculator extends AnyRef

    Permalink
  202. class VarsJ extends AnyRef

    Permalink
  203. class VarsJBridge extends AnyRef

    Permalink

    The bridge between Scala *Vars implementations and the

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

    Permalink
  205. trait Whence extends AnyRef

    Permalink

    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

    Permalink

    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

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

    Permalink

    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]

    Permalink
  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

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

    Permalink

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

  212. trait XmlNodeResponse extends LiftResponse

    Permalink
  213. class XmlResponse extends XmlNodeResponse

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

    Permalink

    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

    Permalink
  216. Value Members

    1. object AddAListener extends Serializable

      Permalink
    2. object AjaxContext extends Serializable

      Permalink
    3. object AjaxType extends Enumeration

      Permalink
    4. object AnyVar

      Permalink
    5. object AppXmlResponse

      Permalink
    6. object AskRender extends CometMessage with Product with Serializable

      Permalink
    7. object BadResponse

      Permalink
    8. object Bindings

      Permalink

      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.

    9. object CSSResponse extends Serializable

      Permalink
    10. object ClearNotices extends CometMessage with Product with Serializable

      Permalink
    11. object CometVersionPair

      Permalink
    12. object ContainerSerializer

      Permalink
    13. object ContentParser

      Permalink
    14. object ContentSecurityPolicy extends Serializable

      Permalink
    15. object ContentSecurityPolicyViolation extends LazyLoggable with Serializable

      Permalink
    16. object ContentSourceRestriction

      Permalink
    17. object ContentType extends Serializable

      Permalink

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

    18. object ContinueResponseException extends Serializable

      Permalink
    19. object CreatedResponse extends Serializable

      Permalink

      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.

    20. object CurrentCometActor extends ThreadGlobal[LiftCometActor]

      Permalink
    21. object CurrentHTTPReqResp extends ThreadGlobal[(HTTPRequest, HTTPResponse)]

      Permalink

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

    22. object CurrentReq extends ThreadGlobal[Req]

      Permalink

      A Thread-global containing the current Req.

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

    23. object DataAttributeProcessorAnswer

      Permalink

      The companion object that has the implicit conversions

    24. object DefaultNotFound extends NotFound with Product with Serializable

      Permalink
    25. object DefaultRoutines

      Permalink

      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.

    26. object DeleteRequest extends RequestType with Product with Serializable

      Permalink
    27. object DoRedirectResponse

      Permalink
    28. object DocType

      Permalink

      Stock XHTML doctypes available to the lift programmer.

    29. object Error extends Serializable

      Permalink
    30. object FieldBinding extends Serializable

      Permalink
    31. object FileParamHolder extends Serializable

      Permalink
    32. object ForbiddenResponse extends Serializable

      Permalink
    33. object FrameRestrictions

      Permalink
    34. object GUIDJsExp

      Permalink

      The companion object for GUIDJsExp that does helpful implicit conversions.

    35. object GetRequest extends RequestType with Product with Serializable

      Permalink
    36. object HeadRequest extends RequestType with Product with Serializable

      Permalink
    37. object Html5ElemAttr

      Permalink
    38. object HttpsRules extends Serializable

      Permalink
    39. object JavaScriptResponse extends Serializable

      Permalink
    40. object JsonResponse extends Serializable

      Permalink
    41. object LiftRules extends LiftRulesMocker

      Permalink

      The Lift configuration singleton

    42. object LiftRulesMocker

      Permalink
    43. object LiftScreenRules extends Factory with FormVendor

      Permalink
    44. object LiftSession

      Permalink
    45. object ListenerManager

      Permalink
    46. object MessageState extends Serializable

      Permalink
    47. object NamedCometListener extends Loggable

      Permalink

      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

    48. object NodeSeqFuncOrSeqNodeSeqFunc

      Permalink
    49. object NotAcceptableResponse extends Serializable

      Permalink
    50. object NotFoundResponse extends Serializable

      Permalink
    51. object Notice extends Serializable

      Permalink
    52. object NoticeType extends Serializable

      Permalink

      Defines the notices types

    53. object OnDiskFileParamHolder extends Serializable

      Permalink
    54. object OptionsRequest extends RequestType with Product with Serializable

      Permalink
    55. object OutputStreamResponse extends Serializable

      Permalink
    56. object PageName extends RequestVar[String]

      Permalink
    57. object PlainTextResponse extends Serializable

      Permalink
    58. object PostRequest extends RequestType with Product with Serializable

      Permalink
    59. object PutRequest extends RequestType with Product with Serializable

      Permalink
    60. object Qop extends Enumeration

      Permalink
    61. object RedirectResponse extends Serializable

      Permalink

      Companion object to RedirectResponse

    62. object RedirectState extends Serializable

      Permalink
    63. object RedirectWithState extends Serializable

      Permalink
    64. object Req

      Permalink

      Helper object for constructing Req instances

    65. object RequestType extends Serializable

      Permalink
    66. object RequestVar

      Permalink

      The companion object to RequestVars

    67. object ResourceServer

      Permalink
    68. object ResponseShortcutException extends Serializable

      Permalink
    69. object RewriteResponse extends Serializable

      Permalink

      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.

    70. object RoundTripInfo

      Permalink

      The companion objects.

      The companion objects. Has tasty implicits

    71. object S extends S

      Permalink

      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

    72. object SHtml extends SHtml

      Permalink

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

    73. object ScreenFieldInfo extends Serializable

      Permalink
    74. object SecurityRules extends Serializable

      Permalink
    75. object SeeOtherResponse extends Serializable

      Permalink

      Companion object to RedirectResponse

    76. object SessionMaster extends LiftActor with Loggable

      Permalink

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

    77. object ShutDown extends Product with Serializable

      Permalink

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

    78. object ShutdownIfPastLifespan extends CometMessage with Product with Serializable

      Permalink
    79. object StrictXHTML1_0Validator extends GenericValidator

      Permalink
    80. object Templates

      Permalink

      Contains functions for obtaining templates

    81. object TransientSnippet

      Permalink

      The companion object to the TransientSnippet trait

    82. object TransitionalXHTML1_0Validator extends GenericValidator

      Permalink
    83. object URLRewriter

      Permalink

      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_?).

    84. object UnauthorizedDigestResponse extends Serializable

      Permalink

      Companion object with builder

    85. object UserAgentCalculator extends Factory

      Permalink
    86. object Warning extends Serializable

      Permalink
    87. object WiringUI

      Permalink

      Surface a user interface on top of Wiring

    88. object WizardRules extends Factory with FormVendor

      Permalink
    89. object XmlResponse

      Permalink
    90. implicit def asyncResolvableTransform[ResolvableType, ResolvedType](implicit asyncResolveProvider: CanResolveAsync[ResolvableType, ResolvedType], innerTransform: CanBind[ResolvedType]): CanBind[ResolvableType]

      Permalink

      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.

    91. package auth

      Permalink
    92. package js

      Permalink
    93. package provider

      Permalink
    94. package rest

      Permalink
    95. package testing

      Permalink

    Inherited from AnyRef

    Inherited from Any

    Ungrouped

    ... just doing innerHtml on