fetch

Type Members

sealed trait ByteRange extends AnyRef
case class Conneg[T](value: T, q: Float = 1) extends Product with Serializable

Represents an acceptable value for content negotiation headers (Accept*).
Represents an acceptable value for content negotiation headers (Accept*).
value
value of the header (see the companion object for header formats).
q
weight of the value, as a float between 0 and 1 inclusive. Bigger weights tell remote servers that the corresponding value is more desirable than values associated with lower weights.
trait ConnegFormat[T] extends HttpGrammar with ValueFormat[Seq[Conneg[T]]]

Used to parse / serialize content negotiation header values.
Used to parse / serialize content negotiation header values.
In order to implement a format for a specific type, application developers only need to provide a Parser instance for that type by implementing the entry method.
sealed trait ETag extends AnyRef

Represents HTTP entity tags.
trait Encoding extends AnyRef

Handles HTTP content encoding.
final case class FullRange(from: Int, to: Int) extends ByteRange with Product with Serializable
class Headers extends Parameters[Headers]
trait HttpGrammar extends RegexParsers
sealed trait Language extends AnyRef

Represents an entity's language.
Represents an entity's language.
These can be used for content negotiation or to describe the language in which a response is written.
A language can either be global or country-specific.
sealed trait MediaType extends AnyRef
class MediaTypeParameters extends Parameters[MediaTypeParameters]
sealed trait Method extends AnyRef
trait Parameters[Self <: Parameters[Self]] extends AnyRef

Stores a list of name / value pairs.
Stores a list of name / value pairs.
Values are stored in their serialized forms as String, but can be manipulated as more specific types provided corresponding instances of ValueReader and ValueWriter are in scope. Default implementations of these can be found in ValueFormat.
final case class PrefixRange(from: Int) extends ByteRange with Product with Serializable
sealed trait Protocol extends AnyRef

Represents a valid URL protocol.
Represents a valid URL protocol.
Supported protocols are declared in the companion object.
Protocol instances can be used to easily create urls:
```
// Verbose:
Protocol.Http.host("github.com")

// Syntactic sugar:
Protocol.Http :/ "github.com"
```
class QueryString extends AnyRef

Represents an Url's query string.
trait Request[A] extends AnyRef

Represents an HTTP request.
Represents an HTTP request.
Instances are created through the companion object. Once an instance is obtained, the request can be configured through "raw" modification methods (
```
method
```
,
```
headers
```
...) as well as specialised helpers such as
```
GET
```
,
```
acceptGzip
```
or
```
/
```
.
/ }}}
acceptGzip }}}
GET }}}
headers }}} as
```
GET
```
,
```
acceptGzip
```
or
```
/
```
.
/ }}}
acceptGzip }}}
GET }}}
method }}} as
```
GET
```
,
```
acceptGzip
```
or
```
/
```
.
/ }}}
acceptGzip }}}
GET }}}
trait RequestEntity extends RequestEntityLike[RequestEntity]
trait RequestEntityLike[+Self <: RequestEntityLike[Self]] extends AnyRef
case class Response[A](status: Status, headers: Headers, body: A) extends Product with Serializable

Represents an HTTP response.
class ResponseEntity extends AnyRef

Represents a raw response entity.

case class Status(code: Int) extends Product with Serializable

Represents an HTTP status code, as defined in RFC 2616.

This class and its companion objects provide various extraction helpers to ease pattern matching. For example:

val res: Response[ResponseEntity] = ???

res.status match {
  case Status.Success(_) => println("Success")
  case _                 => println("Not success")
}

It's also possible to pattern match directly on instances of Response, which can be useful when mapping on requests:

val res: Request[Response[ResponseEntity]] = ???

res map {
  // Match on the 2xx group
  case res @ Status.Success(_)       => println("Success: " + res.body.as[String])
  // Match on HTTP 500
  case Status.InternalServerError(_) => println("Internal server error")
  // Match on everything else
  case _                             => println("Something else entirely")
}

See the companion object for known status codes.

final case class SuffixRange(to: Int) extends ByteRange with Product with Serializable
trait TextRequestEntity extends RequestEntity with RequestEntityLike[TextRequestEntity]
case class Url(protocol: Protocol, host: String, port: Int, path: List[String] = List(), query: QueryString = QueryString(), fragment: Option[String] = None) extends Product with Serializable
class UrlEncoder extends AnyRef
trait ValueFormat[T] extends ValueReader[T] with ValueWriter[T]

Compounds a ValueReader and ValueWriter.
trait ValueReader[T] extends AnyRef

Used to read parameter values from an instance of Parameters.
Used to read parameter values from an instance of Parameters.

Annotations
@implicitNotFound( ... )
trait ValueWriter[T] extends AnyRef

Used to write parameter values to an instance of Parameters.
Used to write parameter values to an instance of Parameters.

Annotations
@implicitNotFound( ... )

Value Members

object ByteRange
object Conneg extends Serializable

Collection of implicit header formats for known content negotiation headers.
val DefaultCharset: Charset

Charset used for request or response entities when none is specified.
object ETag
object Encoding
object Headers
object HttpGrammar
implicit val IntEntityParser: EntityParser[Int]
object Language

Tools for creating instances of Language.
object MediaType

Defines MediaType implementations as well as known types.
object MediaTypeParameters
object Method
object Protocol

Declares known protocols and provides convenience methods.
object QueryString
object Request
object RequestEntity
object Response extends Serializable
object ResponseEntity
object Status extends Serializable

Defines known HTTP status codes, as well as pattern match helpers.
implicit val TextEntityParser: EntityParser[String]
object Url extends Serializable
object ValueFormat
object ValueReader
object ValueWriter
implicit def charsetToConneg(charset: Charset): Conneg[Charset]
implicit def encodingToConneg(encoding: Encoding): Conneg[Encoding]
implicit def fileToEntity(file: File): RequestEntity
implicit def localeToConneg(locale: Locale): Conneg[Locale]
implicit def mediaTypeToConneg(mediaType: MediaType): Conneg[MediaType]
package net
implicit def readerToEntity(reader: Reader): RequestEntity
implicit def streamToEntity(in: InputStream): RequestEntity
implicit def stringToEntity(str: String): RequestEntity
implicit def urlToRequest(url: Url)(implicit engine: HttpEngine): Request[Response[ResponseEntity]]
def writeBytes(in: InputStream, out: OutputStream): Unit

Writes the content of the specified input stream to the specified output stream.
Writes the content of the specified input stream to the specified output stream. Note that this method does not wrap its arguments in buffered streams, nor will it close either stream.
def writeChars(in: Reader, out: Writer): Unit

Writes the content of the specified reader to the specified writer.
Writes the content of the specified reader to the specified writer. Note that this method does not wrap its arguments in buffered implementations, nor will it close either stream.

package fetch

Type Members

sealed trait ByteRange extends AnyRef

case class Conneg[T](value: T, q: Float = 1) extends Product with Serializable

trait ConnegFormat[T] extends HttpGrammar with ValueFormat[Seq[Conneg[T]]]

sealed trait ETag extends AnyRef

trait Encoding extends AnyRef

final case class FullRange(from: Int, to: Int) extends ByteRange with Product with Serializable

class Headers extends Parameters[Headers]

trait HttpGrammar extends RegexParsers

sealed trait Language extends AnyRef

sealed trait MediaType extends AnyRef

class MediaTypeParameters extends Parameters[MediaTypeParameters]

sealed trait Method extends AnyRef

trait Parameters[Self <: Parameters[Self]] extends AnyRef

final case class PrefixRange(from: Int) extends ByteRange with Product with Serializable

sealed trait Protocol extends AnyRef

class QueryString extends AnyRef

trait Request[A] extends AnyRef

trait RequestEntity extends RequestEntityLike[RequestEntity]

trait RequestEntityLike[+Self <: RequestEntityLike[Self]] extends AnyRef

case class Response[A](status: Status, headers: Headers, body: A) extends Product with Serializable

class ResponseEntity extends AnyRef

case class Status(code: Int) extends Product with Serializable

final case class SuffixRange(to: Int) extends ByteRange with Product with Serializable

trait TextRequestEntity extends RequestEntity with RequestEntityLike[TextRequestEntity]

case class Url(protocol: Protocol, host: String, port: Int, path: List[String] = List(), query: QueryString = QueryString(), fragment: Option[String] = None) extends Product with Serializable

class UrlEncoder extends AnyRef

trait ValueFormat[T] extends ValueReader[T] with ValueWriter[T]

trait ValueReader[T] extends AnyRef

trait ValueWriter[T] extends AnyRef

Value Members

object ByteRange

object Conneg extends Serializable

val DefaultCharset: Charset

object ETag

object Encoding

object Headers

object HttpGrammar

implicit val IntEntityParser: EntityParser[Int]

object Language

object MediaType

object MediaTypeParameters

object Method

object Protocol

object QueryString

object Request

object RequestEntity

object Response extends Serializable

object ResponseEntity

object Status extends Serializable

implicit val TextEntityParser: EntityParser[String]

object Url extends Serializable

object ValueFormat

object ValueReader

object ValueWriter

implicit def charsetToConneg(charset: Charset): Conneg[Charset]

implicit def encodingToConneg(encoding: Encoding): Conneg[Encoding]

implicit def fileToEntity(file: File): RequestEntity

implicit def localeToConneg(locale: Locale): Conneg[Locale]

implicit def mediaTypeToConneg(mediaType: MediaType): Conneg[MediaType]

package net

implicit def readerToEntity(reader: Reader): RequestEntity

implicit def streamToEntity(in: InputStream): RequestEntity

implicit def stringToEntity(str: String): RequestEntity

implicit def urlToRequest(url: Url)(implicit engine: HttpEngine): Request[Response[ResponseEntity]]

def writeBytes(in: InputStream, out: OutputStream): Unit

def writeChars(in: Reader, out: Writer): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped