http
The trait that forms the basis for LiftScreen and the Screen instances in Wizard
202 response but without body.
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.
ListenerManager
CometListener
Returning an Atom category document.
The Atom entity was successfully created and is shown to the client.
Returning an Atom document.
Returning an Atom Service Document.
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.
400 Bad Request
400 Bad Request
Your Request was missing an important element. Use this as a last resort if the request appears incorrect.
A "default" implementation of StatelessBehavior.
A "default" implementation of StatelessBehavior. Just ignore everything and return an empty NodeSeq.
Holds either the body or the request input stream, depending on which was requested first
Takes care of the plumbing for building Comet-based Web Apps
Subclass from this class if you're in Java-land and want a CometActor
Subclass from this class if you want a CometActorJ with CometListeners
A case class that contains the information necessary to set up a CometActor
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
registerWithmember 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.
ListenerManager
Holds the Comet identification information
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
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.
Holds information about the content type and subtype including the q parameter and extension information.
This exception is used by LiftSession.
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.
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.
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.
A FileParamHolder contains a file uploaded via a multipart form.
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.
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().
410 Resource Gone
410 Resource Gone
The requested Resource used to exist but no longer does.
A trait defining how stateful the session is
If you're going to use HTML5, then this is the set of properties to use
This trait encapsulates the various choices related to parsing and emitting HTML/XHTML
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
This FileParamHolder stores the uploaded file directly into memory.
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
500 Internal Server Error
500 Internal Server Error
The server encountered an unexpected condition which prevented it from fulfilling the request.
Impersonates a HTTP response having Content-Type = text/javascript
A LiftActorJ with ListenerManager.
A LiftActorJ with ListenerManager. Subclass this class to get a Java-usable LiftActorJ with ListenerManager
LiftRules is the global object that holds all of Lift's configuration.
The LiftSession class containg the session state information
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
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 => {
updateListeners(Tick)
ActorPing.schedule(this, Tick, 1000L)
}
}
}
A client CometActor could look like:
class CometClock extends CometListener {
val registerWith = Ticker
... handling code ...
}
CometListener
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
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.
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.
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
This trait adds a named comet actor on the page.
This trait adds a named comet actor on the page. *
This class keeps a list of comet actors that need to update the UI
204 response but without body.
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.
404 Not Found
404 Not Found
The server has not found anything matching the Request-URI.
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.
200 response but without body.
This set of properties is based on Lift's current XHTML support
This FileParamHolder stores the uploaded file in a temporary file on disk.
Returning an OpenSearch Description Document.
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.
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
the type of item being paginated
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)
The representation of an URI path
301 Redirect.
302
This is a message class for use with ListenerManager and CometListener instances.
This is a message class for use with ListenerManager and CometListener instances.
ListenerManager
CometListener
Mix this into a StatefulSnippet if you want a defined render method.
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
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
is the "normal" render body
is the "fixed" part of the body. This is ignored unless reRender(true)
is the script to be executed on render. This is where you want to put your script
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.)
-- 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
| ... just doing innerHtml on |