LiftRules

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

object RulesSeq extends AnyRef

def addSyncProvider (asyncMeta: AsyncProviderMeta): Unit

Register an AsyncMeta provider in addition to the default Jetty6, Jetty7, and Servlet 3.

def addToPackages (what: Package): Unit

Tells Lift where to find Snippets,Views, Comet Actors and Lift ORM Model object

def addToPackages (what: String): Unit

Tells Lift where to find Snippets,Views, Comet Actors and Lift ORM Model object

val afterSend : RulesSeq[(BasicResponse, HTTPResponse, List[(String, String)], Box[Req]) ⇒ Any]

Holds user functions that are executed after the response was sent to client.

var ajaxDefaultFailure : Box[() ⇒ JsCmd]

The default action to take when the JavaScript action fails

var ajaxEnd : Box[() ⇒ JsCmd]

The JavaScript to execute at the end of an Ajax request (for example, removing the spinning working thingy)

var ajaxPath : String

Contains the Ajax URI path used by Lift to process Ajax requests.

var ajaxPostTimeout : Int

var ajaxRetryCount : Box[Int]

How many times do we retry an Ajax command before calling it a failure?

var ajaxScriptName : () ⇒ String

The name of the Ajax script that manages Ajax requests.

var ajaxScriptUpdateTime : (LiftSession) ⇒ Long

Holds the last update time of the Ajax request.

var ajaxStart : Box[() ⇒ JsCmd]

The JavaScript to execute at the begining of an Ajax request (for example, showing the spinning working thingy)

val allowParallelSnippets : FactoryMaker[Boolean]

Does the current context support parallel snippet execution

def appendGlobalFormBuilder [T] (builder: FormBuilderLocator[T]): Unit

def appendRequestFormBuilder [T] (builder: FormBuilderLocator[T]): Unit

def appendSessionFormBuilder [T] (builder: FormBuilderLocator[T]): Unit

def asInstanceOf [T0] : T0

lazy val asyncProviderMeta : Box[AsyncProviderMeta]

The meta for the detected AsyncProvider given the container we're running in

var attachResourceId : (String) ⇒ String

Attached an ID entity for resource URI specified in link or script tags.

var authentication : HttpAuthentication

The HTTP authentication mechanism that ift will perform.

var autoIncludeAjax : (LiftSession) ⇒ Boolean

Tells Lift if the Ajax JavaScript shoukd be included.

var autoIncludeComet : (LiftSession) ⇒ Boolean

Tells Lift if the Comet JavaScript shoukd be included.

val beforeSend : RulesSeq[(BasicResponse, HTTPResponse, List[(String, String)], Box[Req]) ⇒ Any]

Holds user functions that are executed before sending the response to client.

def buildPackage (end: String): List[String]

Used by Lift to construct full pacakge names fromthe packages provided to addToPackages function

var calcCometPath : (String) ⇒ JsExp

Computes the Comet path by adding additional tokens on top of cometPath

var calcIE6ForResponse : () ⇒ Boolean

var calcIEMode : () ⇒ Boolean

The function that calculates if the response should be rendered in IE6/7 compatibility mode

var calcRequestTimeout : Box[(Req) ⇒ Int]

Put a function that will calculate the request timeout based on the incoming request.

var calculateContextPath : () ⇒ Box[String]

If there is an alternative way of calculating the context path (by default returning Empty)

var calculateXmlHeader : (NodeResponse, Node, Box[String]) ⇒ String

An XML header is inserted at the very beginning of returned XHTML pages.

def clone (): AnyRef

val cometCreation : RulesSeq[CometCreationPF]

Partial function to allow you to build a CometActor from code rather than via reflection

val cometCreationFactory : FactoryMaker[(CometCreationInfo) ⇒ Box[LiftCometActor]]

A factory that will vend comet creators

var cometFailureRetryTimeout : Long

If a Comet request fails timeout for this period of time.

var cometGetTimeout : Int

def cometLogger : Logger

Holds the CometLogger that will be used to log comet activity

def cometLogger_= (newLogger: Logger): Unit

Holds the CometLogger that will be used to log comet activity

var cometPath : String

Contains the Comet URI path used by Lift to process Comet requests.

var cometRequestTimeout : Box[Int]

If you want the AJAX request timeout to be something other than 120 seconds, put the value here

var cometScriptName : () ⇒ String

The name of the Comet script that manages Comet requests.

var cometScriptUpdateTime : (LiftSession) ⇒ Long

Holds the last update time of the Comet request.

var cometServer : () ⇒ String

Calculate the Comet Server (by default, the server that the request was made on, but can do the multi-server thing as well)

def configureLogging : () ⇒ Unit

Holds the function that configures logging.

def configureLogging_= (newConfigurer: () ⇒ Unit): Unit

Holds the function that configures logging.

def context : HTTPContext

Returns the HTTPContext

var convertResponse : PartialFunction[(Any, List[(String, String)], List[HTTPCookie], Req), LiftResponse]

convertResponse is a PartialFunction that reduces a given Tuple4 into a LiftResponse that can then be sent to the browser.

val convertToEntity : FactoryMaker[Boolean]

Should codes that represent entities be converted to XML entities when rendered?

val dateTimeConverter : FactoryMaker[DateTimeConverter]

def defaultGetResource (name: String): Box[URL]

Obtain the resource URL by name

var defaultHeaders : PartialFunction[(NodeSeq, Req), List[(String, String)]]

def defaultLocaleCalculator (request: Box[HTTPRequest]): Locale

def defaultTimeZoneCalculator (request: Box[HTTPRequest]): TimeZone

val deferredSnippetFailure : FactoryMaker[(Failure) ⇒ NodeSeq]

If a deferred snippet has a failure during render, what should we display?

val deferredSnippetTimeout : FactoryMaker[NodeSeq]

If a deferred snippet has a failure during render, what should we display?

var determineContentType : PartialFunction[(Box[Req], Box[String]), String]

A partial function that determines content type based on an incoming Req and Accept header

var devModeFailureResponseCodeOverride : Box[Int]

In Dev mode and Test mode, return a non-200 response code if there is an error on the page (one that would result in the red box with the error message being displayed).

val dispatch : RulesSeq[DispatchPF]

Holds the user's DispatchPF functions that will be executed in stateful context

var displayHelpfulSiteMapMessages_? : Boolean

Set to false if you want to have 404's handled the same way in dev and production mode

def doWith [F, T] (builder: FormBuilderLocator[T])(f: ⇒ F): F

def doWithResource [T] (name: String)(f: (InputStream) ⇒ T): Box[T]

Open a resource by name and process its contents using the supplied function.

def doneBoot : Boolean

Does the LiftRules instance think it's done booting?

val early : RulesSeq[(HTTPRequest) ⇒ Any]

Holds user functions that willbe executed very early in the request processing.

val earlyInStateful : RulesSeq[(Box[Req]) ⇒ Unit]

Execute certain functions early in a Stateful Request

val earlyInStateless : RulesSeq[(Box[Req]) ⇒ Unit]

Execute certain functions early in a Stateful Request

val earlyResponse : RulesSeq[(Req) ⇒ Box[LiftResponse]] with FirstBox[Req, LiftResponse]

var enableContainerSessions : Boolean

var enableLiftGC : Boolean

By default lift uses a garbage-collection mechanism of removing unused bound functions from LiftSesssion.

var encodeJSessionIdInUrl_? : Boolean

Should the JSESSIONID be encoded in the URL if cookies are not supported

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

var exceptionHandler : RulesSeq[ExceptionHandlerPF]

The sequence of partial functions (pattern matching) for handling converting an exception to something to be sent to the browser depending on the current RunMode (development, etc.

val excludePathFromContextPathRewriting : FactoryMaker[(String) ⇒ Boolean]

Update the function here that calculates particular paths to exclused from context path rewriting

var explicitlyParsedSuffixes : Set[String]

When a request is parsed into a Req object, certain suffixes are explicitly split from the last part of the request URI.

def finalize (): Unit

def fixCSS (path: List[String], prefix: Box[String]): Unit

Modifies the root relative paths from the css url-s

var flipDocTypeForIE6 : Boolean

val formAttrs : FactoryMaker[List[String]]

If you use the form attribute in a snippet invocation, what attributes should be copied from the snippet invocation tag to the form tag.

def getClass (): java.lang.Class[_]

var getLiftSession : (Req) ⇒ LiftSession

var getResource : (String) ⇒ Box[URL]

Obtain the resource URL by name

var handleMimeFile : (String, String, String, InputStream) ⇒ FileParamHolder

The function that converts a fieldName, contentType, fileName and an InputStream into a FileParamHolder.

def hashCode (): Int

val htmlProperties : FactoryMaker[(Req) ⇒ HtmlProperties]

A unified set of properties for managing how to treat HTML, XHTML, HTML5.

val httpAuthProtectedResource : RulesSeq[HttpAuthProtectedResourcePF]

Defines the resources that are protected by authentication and authorization.

implicit def inject [T] (implicit man: Manifest[T]): Box[T]

Perform the injection for the given type.

def isInstanceOf [T0] : Boolean

var jsArtifacts : JSArtifacts

Holds the JS library specific UI artifacts.

val jsonOutputConverter : FactoryMaker[(Document) ⇒ String]

The function that converts a scala.

val lazySnippetTimeout : FactoryMaker[TimeSpan]

How long should we wait for all the lazy snippets to render

lazy val liftBuildDate : Date

var liftCoreResourceName : String

The base name of the resource bundle of the lift core code

var liftGCFailureRetryTimeout : Long

The polling interval for background Ajax requests to keep functions to not be garbage collected.

var liftGCPollingInterval : Long

The polling interval for background Ajax requests to prevent functions of being garbage collected.

val liftRequest : RulesSeq[LiftRequestPF]

Get the partial function that defines if a request should be handled by the application (rather than the default container handler)

val liftTagProcessing : RulesSeq[LiftTagPF]

Allows user adding additional Lift tags (the tags must be prefixed by lift namespace such as <lift:xxxx/>).

 - Element label,
 - The Element itselft,
 - The attrbutes
 - The child nodes
 - The page name

lazy val liftVersion : String

def loadResource (name: String): Box[Array[Byte]]

Obtain the resource as an array of bytes by name

def loadResourceAsString (name: String): Box[String]

Obtain the resource as a String by name

def loadResourceAsXml (name: String): Box[NodeSeq]

Obtain the resource as an XML by name.

var localeCalculator : (Box[HTTPRequest]) ⇒ Locale

A function that takes the current HTTP request and returns the current

var localizationLookupFailureNotice : Box[(String, Locale) ⇒ Unit]

The function referenced here is called if there's a localization lookup failure

var localizeStringToXml : (String) ⇒ NodeSeq

A function that defines how a String should be converted to XML for the localization stuff.

var logServiceRequestTiming : Boolean

Controls whether or not the service handling timing messages (Service request (GET) .

var logUnreadRequestVars : Boolean

This variable controls whether RequestVars that have been set but not subsequently read will be logged in Dev mode.

var loggedInTest : Box[() ⇒ Boolean]

Put a test for being logged in into this function

lazy val logger : Logger

var makeCometBreakoutDecision : (LiftSession, Req) ⇒ Unit

A function that takes appropriate action in breaking out of any existing comet requests based on the request, browser type, etc.

val maxConcurrentRequests : FactoryMaker[(Req) ⇒ Int]

The maximum concurrent requests.

var maxMimeFileSize : Long

The maximum allowed size of a single file in a mime multi-part POST.

var maxMimeSize : Long

The maximum allowed size of a complete mime multi-part POST.

def mimeHeaders : Box[Map[String, List[String]]]

Returns any mimeHeaders for the currently invoked handleMimeFile.

def ne (arg0: AnyRef): Boolean

var noCometSessionPage : String

Where to send the user if there's no comet session

val noticesAutoFadeOut : FactoryMaker[(Value) ⇒ Box[(TimeSpan, TimeSpan)]]

Set the default fadeout mechanism for Lift notices.

def noticesContainerId : String

val noticesEffects : FactoryMaker[(Box[Value], String) ⇒ Box[JsCmd]]

Use this to apply various effects to the notices.

var noticesToJsCmd : () ⇒ JsCmd

This function is called to convert the current set of Notices into a JsCmd that will be executed on the client to display the Notices.

def notify (): Unit

def notifyAll (): Unit

val onBeginServicing : RulesSeq[(Req) ⇒ Unit]

Holds user function hooks when the request is about to be processed

val onEndServicing : RulesSeq[(Req, Box[LiftResponse]) ⇒ Unit]

Holds user function hooks when the request was processed

val overwrittenReponseHeaders : FactoryMaker[List[String]]

By default, Http response headers are appended.

var passNotFoundToChain : Boolean

Should pages that are not found be passed along the request processing chain to the next handler outside Lift?

def performTransform (in: LiftResponse): LiftResponse

Runs responseTransformers

val preAccessControlResponse_!! : RulesSeq[(Req) ⇒ Box[LiftResponse]] with FirstBox[Req, LiftResponse]

def prependGlobalFormBuilder [T] (builder: FormBuilderLocator[T]): Unit

def prependRequestFormBuilder [T] (builder: FormBuilderLocator[T]): Unit

def prependSessionFormBuilder [T] (builder: FormBuilderLocator[T]): Unit

var progressListener : (Long, Long, Int) ⇒ Unit

The global multipart progress listener: pBytesRead - The total number of bytes, which have been read so far.

var redirectAjaxOnSessionLoss : Boolean

Set to false if you do not want Ajax/Comet requests that are not associated with a session to cause a page reload

def registerInjection [T] (f: () ⇒ T)(implicit man: Manifest[T]): Unit

Register a function that will inject for the given Manifest

var renderAjaxScript : (LiftSession) ⇒ JsCmd

Returns the JavaScript that manages Ajax requests.

var renderCometPageContents : (LiftSession, Seq[CometVersionPair]) ⇒ JsCmd

Renders that JavaScript that holds Comet identification information

var renderCometScript : (LiftSession) ⇒ JsCmd

Returns the JavaScript that manages Comet requests.

var requestTimedOut : Box[(Req, Any) ⇒ Box[LiftResponse]]

If the request times out (or returns a non-Response) you can intercept the response here and create your own response

val resourceBundleFactories : RulesSeq[ResourceBundleFactoryPF]

val resourceForCurrentLoc : FactoryMaker[() ⇒ List[ResourceBundle]]

Given the current location (based on the Req.

var resourceNames : List[String]

The base name of the resource bundle

var resourceServerPath : String

The path to handle served resources

val responseTransformers : RulesSeq[(LiftResponse) ⇒ LiftResponse]

Holds the user's transformer functions allowing the user to modify a LiftResponse before sending it to client.

def searchSnippetsWithRequestPath (name: String): List[String]

Implementation for snippetNamesToSearch that looks first in a package named by taking the current template path.

var serveAjaxScript : (LiftSession, Req) ⇒ Box[LiftResponse]

Returns the Ajax script as a JavaScript response

var serveCometScript : (LiftSession, Req) ⇒ Box[LiftResponse]

Returns the Comet script as a JavaScript response

var sessionCreator : (HTTPSession, String) ⇒ LiftSession

A function that takes the HTTPSession and the contextPath as parameters and returns a LiftSession reference.

def sessionCreatorForMigratorySessions : (HTTPSession, String) ⇒ LiftSession

A method that returns a function to create migratory sessions.

val sessionInactivityTimeout : FactoryMaker[Box[Long]]

If you want to make the Lift inactivity timeout shorter than the container inactivity timeout, set the inactivity timeout here

def setAjaxEnd (f: Func0[JsCmd]): Unit

Set the Ajax end JavaScript function.

def setAjaxStart (f: Func0[JsCmd]): Unit

Set the Ajax end JavaScript function.

def setContext (in: HTTPContext): Unit

Sets the HTTPContext

def setSiteMap (sm: SiteMap): Unit

Define the sitemap.

def setSiteMapFunc (smf: () ⇒ SiteMap): Unit

Set the sitemap to a function that will be run to generate the sitemap.

def siteMap : Box[SiteMap]

Return the sitemap if set in Boot.

var siteMapFailRedirectLocation : List[String]

The default location to send people if SiteMap access control fails.

val snippetDispatch : RulesSeq[SnippetDispatchPF]

The dispatcher that takes a Snippet and converts it to a DispatchSnippet instance

val snippetFailedFunc : RulesSeq[(SnippetFailure) ⇒ Unit]

Set a snippet failure handler here.

var snippetNamesToSearch : FactoryMaker[(String) ⇒ List[String]]

Function that generates variants on snippet names to search for, given the name from the template.

val snippets : RulesSeq[SnippetPF]

Holds the user's snippet functions that will be executed by lift given a certain path.

val statefulRewrite : RulesSeq[RewritePF]

Holds the user's rewrite functions that can alter the URI parts and query parameters.

val statelessDispatchTable : RulesSeq[DispatchPF]

Holds user's DispatchPF functions that will be executed in a stateless context.

val statelessReqTest : RulesSeq[StatelessReqTestPF]

Certain paths and requests within your application can be marked as stateless and if there is access to Lift's stateful facilities (setting SessionVars, updating function tables, etc.

val statelessRewrite : RulesSeq[RewritePF]

Holds the user's rewrite functions that can alter the URI parts and query parameters.

val statelessSession : FactoryMaker[(Req) ⇒ LiftSession with StatelessSession]

var stdRequestTimeout : Box[Int]

If you want the standard (non-AJAX) request timeout to be something other than 10 seconds, put the value here

val stripComments : FactoryMaker[Boolean]

Should comments be stripped from the served XHTML

val suffixSplitters : RulesSeq[SplitSuffixPF]

Determins the path parts and suffix from given path parts

var supplimentalHeaders : (HTTPResponse) ⇒ Unit

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

var templateCache : Box[TemplateCache[(Locale, List[String]), NodeSeq]]

var templateSuffixes : List[String]

The list of suffixes that Lift looks for in templates.

lazy val theServletAsyncProvider : Box[(HTTPRequest) ⇒ ServletAsyncProvider]

A function that converts the current Request into an AsyncProvider.

var throwOnOutOfScopeVarAccess : Boolean

Should an exception be thrown on out of scope Session and RequestVar access.

var timeZoneCalculator : (Box[HTTPRequest]) ⇒ TimeZone

A function that takes the current HTTP request and returns the current

def toString (): String

val unloadHooks : RulesSeq[() ⇒ Unit]

Hooks to be run when LiftServlet.

var unusedFunctionsLifeTime : Long

If Lift garbage collection is enabled, functions that are not seen in the page for this period of time (given in milliseonds) will be discarded, hence eligibe for garbage collection.

val uriNotFound : RulesSeq[URINotFoundPF]

The list of partial function for defining the behavior of what happens when URI is invalid and you're not using a site map

val urlDecorate : RulesSeq[URLDecoratorPF]

Use this PartialFunction to to automatically add static URL parameters to any URL reference from the markup of Ajax request.

var useXhtmlMimeType : Boolean

If you don't want lift to send the application/xhtml+xml mime type to those browsers that understand it, then set this to { @code false }

def vendForm [T] (implicit man: Manifest[T]): Box[(T, (T) ⇒ Any) ⇒ NodeSeq]

Given a type manifest, vend a form

val viewDispatch : RulesSeq[ViewDispatchPF]

Change this variable to set view dispatching

def wait (): Unit

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

def wait (arg0: Long): Unit

var xhtmlValidator : Box[XHtmlValidator]

Define the XHTML validator

val docType : FactoryMaker[(Req) ⇒ Box[String]]

Set the doc type used.

var formatDate : (Date) ⇒ String

A function to format a Date.

var parseDate : (String) ⇒ Box[Date]

A function that parses a String into a Date.

val rewrite : RulesSeq[RewritePF]

Use statelessRewrite or statefuleRewrite

var servletAsyncProvider : (HTTPRequest) ⇒ ServletAsyncProvider

Provides the async provider instance responsible for suspending/resuming requests

val statelessTest : RulesSeq[StatelessTestPF]

Certain paths within your application can be marked as stateless and if there is access to Lift's stateful facilities (setting SessionVars, updating function tables, etc.