RestHelper

Type Members

final case class AutoJsonXmlAble(obj: Any) extends Product with Serializable

The class that wraps anything for auto conversion to JSON or XML
The class that wraps anything for auto conversion to JSON or XML

Attributes
protected
trait JsonBody extends AnyRef

a trait that extracts the JSON body from a request It is composed with a TestXXX to get the correct thing for the extractor
a trait that extracts the JSON body from a request It is composed with a TestXXX to get the correct thing for the extractor

Attributes
protected
trait JsonTest extends AnyRef

Attributes
protected
type JxCvtPF[T] = PartialFunction[(JsonXmlSelect, T, Req), LiftResponse]

Attributes
protected
trait TestDelete extends AnyRef

A trait that defines the TestDelete extractor.
A trait that defines the TestDelete extractor. Is the request a DELETE and something that expects JSON or XML in the response. Subclass this trait to change the behavior

Attributes
protected
trait TestGet extends AnyRef

A trait that defines the TestGet extractor.
A trait that defines the TestGet extractor. Is the request a GET and something that expects JSON or XML in the response. Subclass this trait to change the behavior

Attributes
protected
trait TestPost[T] extends AnyRef

A trait that defines the TestPost extractor.
A trait that defines the TestPost extractor. Is the request a POST, has JSON or XML data in the post body and something that expects JSON or XML in the response. Subclass this trait to change the behavior

Attributes
protected
trait TestPut[T] extends AnyRef

A trait that defines the TestPut extractor.
A trait that defines the TestPut extractor. Is the request a PUT, has JSON or XML data in the put body and something that expects JSON or XML in the response. Subclass this trait to change the behavior

Attributes
protected
trait TestReq extends AnyRef

A trait that defines the TestReq extractor.
A trait that defines the TestReq extractor. Is the request something that expects JSON, XML in the response. Subclass this trait to change the behavior

Attributes
protected
trait XmlBody extends AnyRef

a trait that extracts the XML body from a request It is composed with a TestXXX to get the correct thing for the extractor
a trait that extracts the XML body from a request It is composed with a TestXXX to get the correct thing for the extractor

Attributes
protected
trait XmlTest extends AnyRef

Attributes
protected

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
object ->

Extract a Pair using the same syntax that you use to make a Pair
Extract a Pair using the same syntax that you use to make a Pair

Attributes
protected
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object Delete

An extractor that tests the request to see if it's a DELETE and if it is, the path and the request are extracted.
An extractor that tests the request to see if it's a DELETE and if it is, the path and the request are extracted. It can be used as:
```
case "api" :: id :: _ Delete req => ...
```
or
```
case Delete("api" :: id :: _, req) => ...
```
case Delete("api" :: id :: _, req) => ... case "api" :: id :: _ Delete req => ... or
```
case Delete("api" :: id :: _, req) => ...
```
case Delete("api" :: id :: _, req) => ...
Attributes
protected
object Get

An extractor that tests the request to see if it's a GET and if it is, the path and the request are extracted.
An extractor that tests the request to see if it's a GET and if it is, the path and the request are extracted. It can be used as:
```
case "api" :: id :: _ Get req => ...
```
or
```
case Get("api" :: id :: _, req) => ...
```
*
case Get("api" :: id :: _, req) => ... case "api" :: id :: _ Get req => ... or
```
case Get("api" :: id :: _, req) => ...
```
*
case Get("api" :: id :: _, req) => ...
Attributes
protected
lazy val JsonDelete: TestDelete with JsonTest

The stable identifier for JsonDelete.
The stable identifier for JsonDelete. You can use it as an extractor.

Attributes
protected
lazy val JsonGet: TestGet with JsonTest

The stable identifier for JsonGet.
The stable identifier for JsonGet. You can use it as an extractor.

Attributes
protected
lazy val JsonPost: TestPost[JValue] with JsonTest with JsonBody

The stable identifier for JsonPost.
The stable identifier for JsonPost. You can use it as an extractor.

Attributes
protected
lazy val JsonPut: TestPut[JValue] with JsonTest with JsonBody

The stable identifier for JsonPut.
The stable identifier for JsonPut. You can use it as an extractor.

Attributes
protected
lazy val JsonReq: TestReq with JsonTest

The stable identifier for JsonReq.
The stable identifier for JsonReq. You can use it as an extractor.

Attributes
protected
object Options

An extractor that tests the request to see if it's an OPTIONS and if it is, the path and the request are extracted.
An extractor that tests the request to see if it's an OPTIONS and if it is, the path and the request are extracted. It can be used as:
```
case "api" :: id :: _ Options req => ...
```
or
```
case Options("api" :: id :: _, req) => ...
```
*
case Options("api" :: id :: _, req) => ... case "api" :: id :: _ Options req => ... or
```
case Options("api" :: id :: _, req) => ...
```
*
case Options("api" :: id :: _, req) => ...
Attributes
protected
object Post

An extractor that tests the request to see if it's a POST and if it is, the path and the request are extracted.
An extractor that tests the request to see if it's a POST and if it is, the path and the request are extracted. It can be used as:
```
case "api" :: id :: _ Post req => ...
```
or
```
case Post("api" :: id :: _, req) => ...
```
case Post("api" :: id :: _, req) => ... case "api" :: id :: _ Post req => ... or
```
case Post("api" :: id :: _, req) => ...
```
case Post("api" :: id :: _, req) => ...
Attributes
protected
object Put

An extractor that tests the request to see if it's a PUT and if it is, the path and the request are extracted.
An extractor that tests the request to see if it's a PUT and if it is, the path and the request are extracted. It can be used as:
```
case "api" :: id :: _ Put req => ...
```
or
```
case Put("api" :: id :: _, req) => ...
```
case Put("api" :: id :: _, req) => ... case "api" :: id :: _ Put req => ... or
```
case Put("api" :: id :: _, req) => ...
```
case Put("api" :: id :: _, req) => ...
Attributes
protected
lazy val XmlDelete: TestDelete with XmlTest

The stable identifier for XmlDelete.
The stable identifier for XmlDelete. You can use it as an extractor.

Attributes
protected
lazy val XmlGet: TestGet with XmlTest

The stable identifier for XmlGet.
The stable identifier for XmlGet. You can use it as an extractor.

Attributes
protected
lazy val XmlPost: TestPost[Elem] with XmlTest with XmlBody

The stable identifier for XmlPost.
The stable identifier for XmlPost. You can use it as an extractor.

Attributes
protected
lazy val XmlPut: TestPut[Elem] with XmlTest with XmlBody

The stable identifier for XmlPut.
The stable identifier for XmlPut. You can use it as an extractor.

Attributes
protected
lazy val XmlReq: TestReq with XmlTest

The stable identifier for XmlReq.
The stable identifier for XmlReq. You can use it as an extractor.

Attributes
protected
def andThen[C](k: (() ⇒ Box[LiftResponse]) ⇒ C): PartialFunction[Req, C]

Definition Classes
PartialFunction → Function1
def anyToJValue(in: Any): Box[JValue]

Take any value and convert it into a JValue.
Take any value and convert it into a JValue. Full box if it works, empty if it does

Attributes
protected
def apply(in: Req): () ⇒ Box[LiftResponse]

Apply the Rest helper
Apply the Rest helper

Definition Classes
RestHelper → Function1
def applyOrElse[A1 <: Req, B1 >: () ⇒ Box[LiftResponse]](x: A1, default: (A1) ⇒ B1): B1

Definition Classes
PartialFunction
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit def asyncBoxToResponse[AsyncResolvableType, T](asyncBoxContainer: AsyncResolvableType)(implicit asyncResolveProvider: CanResolveAsync[AsyncResolvableType, Box[T]], responseCreator: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

If we're returning a future, then automatically turn the request into an Async request
If we're returning a future, then automatically turn the request into an Async request
T
the type
returns
Nothing

Attributes
protected
implicit def asyncToResponse[AsyncResolvableType, T](asyncContainer: AsyncResolvableType)(implicit asyncResolveProvider: CanResolveAsync[AsyncResolvableType, T], responseCreator: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

If we're returning a future, then automatically turn the request into an Async request
If we're returning a future, then automatically turn the request into an Async request
T
the type
returns
Nothing

Attributes
protected
def auto(in: Box[Any]): Box[AutoJsonXmlAble]

Wrap a Box of anything for autoconversion to JSON or XML
Wrap a Box of anything for autoconversion to JSON or XML

Attributes
protected
def auto(in: Any): Box[AutoJsonXmlAble]

wrap anything for autoconversion to JSON or XML
wrap anything for autoconversion to JSON or XML

Attributes
protected
implicit def boxFuncToResp[T](in: () ⇒ Box[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

Turn a () => Box[T] into the return type expected by DispatchPF.
Turn a () => Box[T] into the return type expected by DispatchPF. Note that this method will return messages from Failure() and return codes and messages from ParamFailure[Int[(msg, _, _, code)

Attributes
protected
implicit def boxToResp[T](in: Box[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

Turn a Box[T] into the return type expected by DispatchPF.
Turn a Box[T] into the return type expected by DispatchPF. Note that this method will return messages from Failure() and return codes and messages from ParamFailure[Int[(msg, _, _, code)

Attributes
protected
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compose[A](g: (A) ⇒ Req): (A) ⇒ () ⇒ Box[LiftResponse]

Definition Classes
Function1
Annotations
@unspecialized()
implicit lazy val convertAutoJsonXmlAble: PartialFunction[(JsonXmlSelect, AutoJsonXmlAble, Req), LiftResponse]

An implicit conversion that converts AutoJsonXmlAble into JSON or XML
An implicit conversion that converts AutoJsonXmlAble into JSON or XML

Attributes
protected
implicit lazy val convertJsonXmlAble: PartialFunction[(JsonXmlSelect, JsonXmlAble, Req), LiftResponse]

The default way to convert a JsonXmlAble into JSON or XML
The default way to convert a JsonXmlAble into JSON or XML

Attributes
protected
def createXmlResponse(in: Node): LiftResponse

Override this method to create an AppXmlResponse with the mime type application/xml rather then text/xml
Override this method to create an AppXmlResponse with the mime type application/xml rather then text/xml

Attributes
protected
def defaultGetAsJson: Boolean

If the headers and the suffix say nothing about the response type, should we default to JSON.
If the headers and the suffix say nothing about the response type, should we default to JSON. By default, yes, override to change the behavior.

Attributes
protected
def defaultGetAsXml: Boolean

If the headers and the suffix say nothing about the response type, should we default to XML.
If the headers and the suffix say nothing about the response type, should we default to XML. By default, no, override to change the behavior.

Attributes
protected
def emptyToResp(eb: EmptyBox): Box[LiftResponse]

Attributes
protected
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
implicit def formats: Formats

Return the implicit Formats instance for JSON conversion
Return the implicit Formats instance for JSON conversion

Attributes
protected
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def isDefinedAt(in: Req): Boolean

Is the Rest helper defined for a given request
Is the Rest helper defined for a given request

Definition Classes
RestHelper → PartialFunction
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def jsCmdToResp(in: JsCmd): LiftResponse

Convert a JsCmd to a LiftResponse
implicit def jsExpToResp(in: JsExp): LiftResponse

Convert a JsExp to a LiftResponse
def jsonResponse_?(in: Req): Boolean

Will the request accept a JSON response? Yes if the Accept header contains "text/json", "application/json" or the Accept header is missing or contains "star/star" and the suffix is "json".
Will the request accept a JSON response? Yes if the Accept header contains "text/json", "application/json" or the Accept header is missing or contains "star/star" and the suffix is "json". Override this method to provide your own logic. If there's no suffix, no accepts (or it's "star/star") then look to either the Content-Type header or the defaultGetAsJson flag

Attributes
protected
implicit def jsonToResp(in: JValue): LiftResponse

Convert a JValue to a LiftResponse
implicit def jxSel(req: Req): BoxOrRaw[JsonXmlSelect]

A function that chooses JSON or XML based on the request..
A function that chooses JSON or XML based on the request.. Use with serveType
def lift: (Req) ⇒ Option[() ⇒ Box[LiftResponse]]

Definition Classes
PartialFunction
implicit def listStringToSuper(in: List[String]): SuperListString

returns
a SuperString with more available methods such as roboSplit or commafy

Attributes
protected
implicit def listToServeMagic(in: List[String]): ListServeMagic

Allows you to use >> after a path list to handle all the cases where you have a prefix for a series of differ suffixes with the same path prefix.
Allows you to use >> after a path list to handle all the cases where you have a prefix for a series of differ suffixes with the same path prefix. For example: serve("foo" / "bar" >> { case baz :: Nil Post _ => ... case Nil Get _ => ... })

Attributes
protected
def mergeJson(original: JValue, toMerge: JValue): JValue

Take an original piece of JSON (most probably, JObject and replace all the JFields with those in toMerge
Take an original piece of JSON (most probably, JObject and replace all the JFields with those in toMerge

Attributes
protected
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
implicit def nodeToResp(in: Node): LiftResponse

Convert a Node to an XmlResponse
Convert a Node to an XmlResponse

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def optionFuncToResp[T](in: () ⇒ Option[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

Turn an Option[T] into the return type expected by DispatchPF.
Turn an Option[T] into the return type expected by DispatchPF.

Attributes
protected
implicit def optionToResp[T](in: Option[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

Turn an Option[T] into the return type expected by DispatchPF.
Turn an Option[T] into the return type expected by DispatchPF.

Attributes
protected
def orElse[A1 <: Req, B1 >: () ⇒ Box[LiftResponse]](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Definition Classes
PartialFunction
def runWith[U](action: (() ⇒ Box[LiftResponse]) ⇒ U): (Req) ⇒ Boolean

Definition Classes
PartialFunction
def serve(handler: PartialFunction[Req, () ⇒ Box[LiftResponse]]): Unit

Add request handlers
Add request handlers

Attributes
protected
def serveJx[T](pf: PartialFunction[Req, BoxOrRaw[T]])(implicit cvt: JxCvtPF[T]): Unit

Serve a request returning either JSON or XML.
Serve a request returning either JSON or XML.
pf
-- a Partial Function that converts the request into an intermediate response.
cvt
-- convert the intermediate response to a LiftResponse based on the request being for XML or JSON. If T is JsonXmlAble, there are built-in converters. Further, you can return auto(thing) and that will invoke built-in converters as well. The built-in converters use Lift JSON's Extraction.decompose to convert the object into JSON and then Xml.toXml() to convert to XML.

Attributes
protected
def serveJxa(pf: PartialFunction[Req, BoxOrRaw[Any]]): Unit

Serve a request returning either JSON or XML.
Serve a request returning either JSON or XML.
pf
-- a Partial Function that converts the request into Any (note that the response must be convertable into JSON vis Lift JSON Extraction.decompose

Attributes
protected
def serveType[T, SelectType](selection: (Req) ⇒ BoxOrRaw[SelectType])(pf: PartialFunction[Req, BoxOrRaw[T]])(implicit cvt: PartialFunction[(SelectType, T, Req), LiftResponse]): Unit

Serve a given request by determining the request type, computing the response and then converting the response to the given type (e.g., JSON or XML).

Serve a given request by determining the request type, computing the response and then converting the response to the given type (e.g., JSON or XML).

selection
-- a function that determines the response type based on the Req.
pf
-- a PartialFunction that converts the request to a response type (e.g., a case class that contains the response).
cvt
-- a function that converts from the response type to a the appropriate LiftResponse based on the selected response type.

Attributes
protected
implicit def stringToSuper(in: String): SuperString

returns
a SuperString with more available methods such as roboSplit or commafy

Attributes
protected
def suplimentalJsonResponse_?(in: Req): Boolean

If there are additional custom rules (e.g., looking at query parameters) you can override this method which is consulted if the other rules in jsonResponse_? fail
If there are additional custom rules (e.g., looking at query parameters) you can override this method which is consulted if the other rules in jsonResponse_? fail

Attributes
protected
def suplimentalXmlResponse_?(in: Req): Boolean

If there are additional custom rules (e.g., looking at query parameters) you can override this method which is consulted if the other rules in xmlResponse_? fail
If there are additional custom rules (e.g., looking at query parameters) you can override this method which is consulted if the other rules in xmlResponse_? fail

Attributes
protected
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
implicit def thingToResp[T](in: T)(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

Turn T into the return type expected by DispatchPF as long as we can convert T to a LiftResponse.
Turn T into the return type expected by DispatchPF as long as we can convert T to a LiftResponse.

Attributes
protected
def toString(): String

Definition Classes
Function1 → AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def xmlResponse_?(in: Req): Boolean

Will the request accept an XML response? Yes if the Accept header contains "application/xml" or "text/xml" or the Accept header is missing or contains "star/star" and the suffix is "xml".
Will the request accept an XML response? Yes if the Accept header contains "application/xml" or "text/xml" or the Accept header is missing or contains "star/star" and the suffix is "xml". Override this method to provide your own logic. If there's no suffix, no accepts (or it's "star/star") then look to either the Content-Type header or the defaultGetAsXml flag.

Attributes
protected

Related Doc: package rest

trait RestHelper extends DispatchPF

Type Members

final case class AutoJsonXmlAble(obj: Any) extends Product with Serializable

trait JsonBody extends AnyRef

trait JsonTest extends AnyRef

type JxCvtPF[T] = PartialFunction[(JsonXmlSelect, T, Req), LiftResponse]

trait TestDelete extends AnyRef

trait TestGet extends AnyRef

trait TestPost[T] extends AnyRef

trait TestPut[T] extends AnyRef

trait TestReq extends AnyRef

trait XmlBody extends AnyRef

trait XmlTest extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

object ->

final def ==(arg0: Any): Boolean

object Delete

object Get

lazy val JsonDelete: TestDelete with JsonTest

lazy val JsonGet: TestGet with JsonTest

lazy val JsonPost: TestPost[JValue] with JsonTest with JsonBody

lazy val JsonPut: TestPut[JValue] with JsonTest with JsonBody

lazy val JsonReq: TestReq with JsonTest

object Options

object Post

object Put

lazy val XmlDelete: TestDelete with XmlTest

lazy val XmlGet: TestGet with XmlTest

lazy val XmlPost: TestPost[Elem] with XmlTest with XmlBody

lazy val XmlPut: TestPut[Elem] with XmlTest with XmlBody

lazy val XmlReq: TestReq with XmlTest

def andThen[C](k: (() ⇒ Box[LiftResponse]) ⇒ C): PartialFunction[Req, C]

def anyToJValue(in: Any): Box[JValue]

def apply(in: Req): () ⇒ Box[LiftResponse]

def applyOrElse[A1 <: Req, B1 >: () ⇒ Box[LiftResponse]](x: A1, default: (A1) ⇒ B1): B1

final def asInstanceOf[T0]: T0

implicit def asyncBoxToResponse[AsyncResolvableType, T](asyncBoxContainer: AsyncResolvableType)(implicit asyncResolveProvider: CanResolveAsync[AsyncResolvableType, Box[T]], responseCreator: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

implicit def asyncToResponse[AsyncResolvableType, T](asyncContainer: AsyncResolvableType)(implicit asyncResolveProvider: CanResolveAsync[AsyncResolvableType, T], responseCreator: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

def auto(in: Box[Any]): Box[AutoJsonXmlAble]

def auto(in: Any): Box[AutoJsonXmlAble]

implicit def boxFuncToResp[T](in: () ⇒ Box[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

implicit def boxToResp[T](in: Box[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

def clone(): AnyRef

def compose[A](g: (A) ⇒ Req): (A) ⇒ () ⇒ Box[LiftResponse]

implicit lazy val convertAutoJsonXmlAble: PartialFunction[(JsonXmlSelect, AutoJsonXmlAble, Req), LiftResponse]

implicit lazy val convertJsonXmlAble: PartialFunction[(JsonXmlSelect, JsonXmlAble, Req), LiftResponse]

def createXmlResponse(in: Node): LiftResponse

def defaultGetAsJson: Boolean

def defaultGetAsXml: Boolean

def emptyToResp(eb: EmptyBox): Box[LiftResponse]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

implicit def formats: Formats

final def getClass(): Class[_]

def hashCode(): Int

def isDefinedAt(in: Req): Boolean

final def isInstanceOf[T0]: Boolean

implicit def jsCmdToResp(in: JsCmd): LiftResponse

implicit def jsExpToResp(in: JsExp): LiftResponse

def jsonResponse_?(in: Req): Boolean

implicit def jsonToResp(in: JValue): LiftResponse

implicit def jxSel(req: Req): BoxOrRaw[JsonXmlSelect]

def lift: (Req) ⇒ Option[() ⇒ Box[LiftResponse]]

implicit def listStringToSuper(in: List[String]): SuperListString

implicit def listToServeMagic(in: List[String]): ListServeMagic

def mergeJson(original: JValue, toMerge: JValue): JValue

final def ne(arg0: AnyRef): Boolean

implicit def nodeToResp(in: Node): LiftResponse

final def notify(): Unit

final def notifyAll(): Unit

implicit def optionFuncToResp[T](in: () ⇒ Option[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

implicit def optionToResp[T](in: Option[T])(implicit c: (T) ⇒ LiftResponse): () ⇒ Box[LiftResponse]

def orElse[A1 <: Req, B1 >: () ⇒ Box[LiftResponse]](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

def runWith[U](action: (() ⇒ Box[LiftResponse]) ⇒ U): (Req) ⇒ Boolean

def serve(handler: PartialFunction[Req, () ⇒ Box[LiftResponse]]): Unit