EmberClient

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def expect[A](s: String)(implicit d: EntityDecoder[F, A]): F[A]

Submits a GET request to the URI specified by the String and decodes the response on success.
Submits a GET request to the URI specified by the String and decodes the response on success. On failure, the status code is returned. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
def expect[A](uri: Uri)(implicit d: EntityDecoder[F, A]): F[A]

Submits a GET request to the specified URI and decodes the response on success.
Submits a GET request to the specified URI and decodes the response on success. On failure, the status code is returned. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
def expect[A](req: F[Request[F]])(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
def expect[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[A]

Submits a request and decodes the response on success.
Submits a request and decodes the response on success. On failure, the status code is returned. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
def expectOption[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[Option[A]]

Definition Classes
EmberClient → Client
def expectOptionOr[A](req: Request[F])(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[Option[A]]

Definition Classes
EmberClient → Client
def expectOr[A](s: String)(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
def expectOr[A](uri: Uri)(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
def expectOr[A](req: F[Request[F]])(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
def expectOr[A](req: Request[F])(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
def fetch[A](req: F[Request[F]])(f: (Response[F]) ⇒ F[A]): F[A]

Submits a request, and provides a callback to process the response.
Submits a request, and provides a callback to process the response.
req
An effect of the request to submit
f
A callback for the response to req. The underlying HTTP connection is disposed when the returned task completes. Attempts to read the response body afterward will result in an error.
returns
The result of applying f to the response to req

Definition Classes
EmberClient → Client
def fetch[A](req: Request[F])(f: (Response[F]) ⇒ F[A]): F[A]

Submits a request, and provides a callback to process the response.
Submits a request, and provides a callback to process the response.
req
The request to submit
f
A callback for the response to req. The underlying HTTP connection is disposed when the returned task completes. Attempts to read the response body afterward will result in an error.
returns
The result of applying f to the response to req

Definition Classes
EmberClient → Client
def fetchAs[A](req: F[Request[F]])(implicit d: EntityDecoder[F, A]): F[A]

Submits a request and decodes the response, regardless of the status code.
Submits a request and decodes the response, regardless of the status code. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
def fetchAs[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[A]

Submits a request and decodes the response, regardless of the status code.
Submits a request and decodes the response, regardless of the status code. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def get[A](s: String)(f: (Response[F]) ⇒ F[A]): F[A]

Submits a request and decodes the response on success.
Submits a request and decodes the response on success. On failure, the status code is returned. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
def get[A](uri: Uri)(f: (Response[F]) ⇒ F[A]): F[A]

Submits a GET request, and provides a callback to process the response.
Submits a GET request, and provides a callback to process the response.
uri
The URI to GET
f
A callback for the response to a GET on uri. The underlying HTTP connection is disposed when the returned task completes. Attempts to read the response body afterward will result in an error.
returns
The result of applying f to the response to req

Definition Classes
EmberClient → Client
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def run(req: Request[F]): Resource[F, Response[F]]

Definition Classes
EmberClient → Client
def state: F[(Int, Map[RequestKey, Int])]

The reason for this extra class.
The reason for this extra class. This allows you to see the present state of the underlying Pool, without having access to the pool itself.
The first element represents total connections in the pool, the second is a mappying between the number of connections in the pool for each requestKey.
def status(req: F[Request[F]]): F[Status]

Submits a request and returns the response status
Submits a request and returns the response status

Definition Classes
EmberClient → Client
def status(req: Request[F]): F[Status]

Submits a request and returns the response status
Submits a request and returns the response status

Definition Classes
EmberClient → Client
def stream(req: Request[F]): Stream[F, Response[F]]

Definition Classes
EmberClient → Client
def streaming[A](req: F[Request[F]])(f: (Response[F]) ⇒ Stream[F, A]): Stream[F, A]

Definition Classes
EmberClient → Client
def streaming[A](req: Request[F])(f: (Response[F]) ⇒ Stream[F, A]): Stream[F, A]

Definition Classes
EmberClient → Client
def successful(req: F[Request[F]]): F[Boolean]

Submits a request and returns true if and only if the response status is successful
Submits a request and returns true if and only if the response status is successful

Definition Classes
EmberClient → Client
def successful(req: Request[F]): F[Boolean]

Submits a request and returns true if and only if the response status is successful
Submits a request and returns true if and only if the response status is successful

Definition Classes
EmberClient → Client
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toHttpApp: HttpApp[F]

Returns this client as an HttpApp.
Returns this client as an HttpApp. It is the responsibility of callers of this service to run the response body to dispose of the underlying HTTP connection.
This is intended for use in proxy servers. fetch, fetchAs, toKleisli, and streaming are safer alternatives, as their signatures guarantee disposal of the HTTP connection.

Definition Classes
EmberClient → Client
def toKleisli[A](f: (Response[F]) ⇒ F[A]): Kleisli[F, Request[F], A]

Returns this client as a Kleisli.
Returns this client as a Kleisli. All connections created by this service are disposed on completion of callback task f.
This method effectively reverses the arguments to fetch, and is preferred when an HTTP client is composed into a larger Kleisli function, or when a common response callback is used by many call sites.

Definition Classes
EmberClient → Client
def toString(): String

Definition Classes
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( ... )

Deprecated Value Members

def getAs[A](s: String)(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
Annotations
@deprecated
Deprecated
(Since version 0.14) Use expect
def getAs[A](uri: Uri)(implicit d: EntityDecoder[F, A]): F[A]

Submits a GET request and decodes the response.
Submits a GET request and decodes the response. The underlying HTTP connection is closed at the completion of the decoding.

Definition Classes
EmberClient → Client
Annotations
@deprecated
Deprecated
(Since version 0.14) Use expect
def prepAs[T](req: F[Request[F]])(implicit d: EntityDecoder[F, T]): F[T]

Definition Classes
EmberClient → Client
Annotations
@deprecated
Deprecated
(Since version 0.14) Use expect
def prepAs[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[A]

Definition Classes
EmberClient → Client
Annotations
@deprecated
Deprecated
(Since version 0.14) Use expect
def toHttpService: HttpService[F]

Returns this client as an HttpService.
Returns this client as an HttpService. It is the responsibility of callers of this service to run the response body to dispose of the underlying HTTP connection.
This is intended for use in proxy servers. fetch, fetchAs, toKleisli, and streaming are safer alternatives, as their signatures guarantee disposal of the HTTP connection.

Definition Classes
EmberClient → Client
Annotations
@deprecated
Deprecated
(Since version 0.19) Use toHttpApp. Call .mapF(OptionT.liftF) if OptionT is really desired.
def toService[A](f: (Response[F]) ⇒ F[A]): Service[F, Request[F], A]

Definition Classes
EmberClient → Client
Annotations
@deprecated
Deprecated
(Since version 0.18) Use toKleisli

Related Doc: package client

final class EmberClient[F[_]] extends Client[F]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expect[A](s: String)(implicit d: EntityDecoder[F, A]): F[A]

def expect[A](uri: Uri)(implicit d: EntityDecoder[F, A]): F[A]

def expect[A](req: F[Request[F]])(implicit d: EntityDecoder[F, A]): F[A]

def expect[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[A]

def expectOption[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[Option[A]]

def expectOptionOr[A](req: Request[F])(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[Option[A]]

def expectOr[A](s: String)(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

def expectOr[A](uri: Uri)(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

def expectOr[A](req: F[Request[F]])(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

def expectOr[A](req: Request[F])(onError: (Response[F]) ⇒ F[Throwable])(implicit d: EntityDecoder[F, A]): F[A]

def fetch[A](req: F[Request[F]])(f: (Response[F]) ⇒ F[A]): F[A]

def fetch[A](req: Request[F])(f: (Response[F]) ⇒ F[A]): F[A]

def fetchAs[A](req: F[Request[F]])(implicit d: EntityDecoder[F, A]): F[A]

def fetchAs[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[A]

def finalize(): Unit

def get[A](s: String)(f: (Response[F]) ⇒ F[A]): F[A]

def get[A](uri: Uri)(f: (Response[F]) ⇒ F[A]): F[A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def run(req: Request[F]): Resource[F, Response[F]]

def state: F[(Int, Map[RequestKey, Int])]

def status(req: F[Request[F]]): F[Status]

def status(req: Request[F]): F[Status]

def stream(req: Request[F]): Stream[F, Response[F]]

def streaming[A](req: F[Request[F]])(f: (Response[F]) ⇒ Stream[F, A]): Stream[F, A]

def streaming[A](req: Request[F])(f: (Response[F]) ⇒ Stream[F, A]): Stream[F, A]

def successful(req: F[Request[F]]): F[Boolean]

def successful(req: Request[F]): F[Boolean]

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

def toHttpApp: HttpApp[F]

def toKleisli[A](f: (Response[F]) ⇒ F[A]): Kleisli[F, Request[F], A]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Deprecated Value Members

def getAs[A](s: String)(implicit d: EntityDecoder[F, A]): F[A]

def getAs[A](uri: Uri)(implicit d: EntityDecoder[F, A]): F[A]

def prepAs[T](req: F[Request[F]])(implicit d: EntityDecoder[F, T]): F[T]

def prepAs[A](req: Request[F])(implicit d: EntityDecoder[F, A]): F[A]

def toHttpService: HttpService[F]

def toService[A](f: (Response[F]) ⇒ F[A]): Service[F, Request[F], A]

Inherited from Client[F]

Inherited from AnyRef

Inherited from Any

Ungrouped