Module cowboy_req

Data Types

body_opts()

body_opts() = [{continue, boolean()} | {length, non_neg_integer()} | {read_length, non_neg_integer()} | {read_timeout, timeout()} | {transfer_decode, transfer_decode_fun(), any()} | {content_decode, content_decode_fun()}]

content_decode_fun()

content_decode_fun() = fun((binary()) -> {ok, binary()} | {error, atom()})

cookie_opts()

cookie_opts() = cow_cookie:cookie_opts()

req()

abstract datatype: req()

resp_body_fun()

resp_body_fun() = fun((any(), module()) -> ok)

transfer_decode_fun()

transfer_decode_fun() = fun((binary(), any()) -> cow_http_te:decode_ret())

Function Index

append_buffer/2
binding/2
binding/3
bindings/1
body/1
body/2
body_length/1
body_qs/1
body_qs/2
chunk/2
chunked_reply/2
chunked_reply/3
compact/1
continue/1
cookie/2
cookie/3
cookies/1
delete_resp_header/2
ensure_response/2
get/2
has_body/1
has_resp_body/1
has_resp_header/2
header/2
header/3
headers/1
host/1
host_info/1
host_url/1
lock/1
maybe_reply/2
meta/2
meta/3
method/1
new/14
parse_header/2
parse_header/3
part/1
part_body/1
part_body/2
path/1
path_info/1
peer/1
port/1
qs/1
qs_val/2
qs_val/3
qs_vals/1
reply/2
reply/3
reply/4
set/2
set_bindings/4
set_meta/3
set_resp_body/2
set_resp_body_fun/2
set_resp_body_fun/3
set_resp_cookie/4
set_resp_header/3
to_list/1
upgrade_reply/3
url/1
version/1

Function Details

append_buffer/2

append_buffer(Suffix::binary(), Req) -> Req

binding/2

binding(Name::atom(), Req) -> {any() | undefined, Req}

binding/3

binding(Name::atom(), Req, Default) -> {any() | Default, Req}

bindings/1

bindings(Req) -> {[{atom(), any()}], Req}

body/1

body(Req) -> {ok, binary(), Req} | {more, binary(), Req} | {error, atom()}

body/2

body(Req, Opts::body_opts()) -> {ok, binary(), Req} | {more, binary(), Req} | {error, atom()}

body_length/1

body_length(Req) -> {undefined | non_neg_integer(), Req}

body_qs/1

body_qs(Req) -> {ok, [{binary(), binary() | true}], Req} | {error, atom()}

body_qs/2

body_qs(Req, Opts::body_opts()) -> {ok, [{binary(), binary() | true}], Req} | {badlength, Req} | {error, atom()}

chunk/2

chunk(Data::iodata(), Http_req::req()) -> ok | {error, atom()}

chunked_reply/2

chunked_reply(Status::cowboy:http_status(), Req) -> {ok, Req}

chunked_reply/3

chunked_reply(Status::cowboy:http_status(), Headers::cowboy:http_headers(), Req) -> {ok, Req}

compact/1

compact(Req) -> Req

continue/1

continue(Http_req::req()) -> ok | {error, atom()}

cookie/2

cookie(Name::binary(), Req) -> {binary() | undefined, Req}

cookie/3

cookie(Name::binary(), Req, Default) -> {binary() | Default, Req}

cookies/1

cookies(Req) -> {[{binary(), binary()}], Req}

delete_resp_header/2

delete_resp_header(Name::binary(), Req) -> Req

ensure_response/2

ensure_response(Http_req::req(), Status::cowboy:http_status()) -> ok

get/2

get(List::atom(), Req::req()) -> any()

has_body/1

has_body(Req::req()) -> boolean()

has_resp_body/1

has_resp_body(Http_req::req()) -> boolean()

has_resp_header/2

has_resp_header(Name::binary(), Http_req::req()) -> boolean()

header/2

header(Name::binary(), Req) -> {binary() | undefined, Req}

header/3

header(Name::binary(), Req, Default) -> {binary() | Default, Req}

headers/1

headers(Req) -> {cowboy:http_headers(), Req}

host/1

host(Req) -> {binary(), Req}

host_info/1

host_info(Req) -> {cowboy_router:tokens() | undefined, Req}

host_url/1

host_url(Req) -> {undefined | binary(), Req}

lock/1

lock(Req) -> Req

maybe_reply/2

maybe_reply(Stacktrace::[{module(), atom(), arity() | [term()], term()}], Req::req()) -> ok

meta/2

meta(Name::atom(), Req) -> {any() | undefined, Req}

meta/3

meta(Name::atom(), Req, Default::any()) -> {any(), Req}

method/1

method(Req) -> {binary(), Req}

new/14

new(Socket::any(), Transport::module(), Peer::undefined | {inet:ip_address(), inet:port_number()}, Method::binary(), Path::binary(), Query::binary(), Version::cowboy:http_version(), Headers::cowboy:http_headers(), Host::binary(), Port::inet:port_number() | undefined, Buffer::binary(), CanKeepalive::boolean(), Compress::boolean(), OnResponse::undefined | cowboy:onresponse_fun()) -> req()

parse_header/2

parse_header(Name::binary(), Req) -> {ok, any(), Req} | {undefined, binary(), Req} | {error, badarg}

parse_header/3

parse_header(Name::binary(), Req, Default::any()) -> {ok, any(), Req} | {undefined, binary(), Req} | {error, badarg}

part/1

part(Req) -> {ok, cow_multipart:headers(), Req} | {done, Req}

part_body/1

part_body(Req) -> {ok, binary(), Req} | {more, binary(), Req}

part_body/2

part_body(Req, Opts::body_opts()) -> {ok, binary(), Req} | {more, binary(), Req}

path/1

path(Req) -> {binary(), Req}

path_info/1

path_info(Req) -> {cowboy_router:tokens() | undefined, Req}

peer/1

peer(Req) -> {{inet:ip_address(), inet:port_number()}, Req}

port/1

port(Req) -> {inet:port_number(), Req}

qs/1

qs(Req) -> {binary(), Req}

qs_val/2

qs_val(Name::binary(), Req) -> {binary() | true | undefined, Req}

qs_val/3

qs_val(Name::binary(), Req, Default) -> {binary() | true | Default, Req}

qs_vals/1

qs_vals(Req) -> {[{binary(), binary() | true}], Req}

reply/2

reply(Status::cowboy:http_status(), Req) -> {ok, Req}

reply/3

reply(Status::cowboy:http_status(), Headers::cowboy:http_headers(), Req) -> {ok, Req}

reply/4

reply(Status::cowboy:http_status(), Headers::cowboy:http_headers(), Body::iodata() | {non_neg_integer() | resp_body_fun()}, Req) -> {ok, Req}

set/2

set(Tail::[{atom(), any()}], Req) -> Req

set_bindings/4

set_bindings(HostInfo::cowboy_router:tokens(), PathInfo::cowboy_router:tokens(), Bindings::cowboy_router:bindings(), Req) -> Req

set_meta/3

set_meta(Name::atom(), Value::any(), Req) -> Req

set_resp_body/2

set_resp_body(Body::iodata(), Req) -> Req

set_resp_body_fun/2

set_resp_body_fun(StreamFun::resp_body_fun(), Req) -> Req

set_resp_body_fun/3

set_resp_body_fun(StreamLen::non_neg_integer(), StreamFun::resp_body_fun(), Req) -> Req

set_resp_cookie/4

set_resp_cookie(Name::iodata(), Value::iodata(), Opts::cookie_opts(), Req) -> Req

set_resp_header/3

set_resp_header(Name::binary(), Value::iodata(), Req) -> Req

to_list/1

to_list(Req::req()) -> [{atom(), any()}]

upgrade_reply/3

upgrade_reply(Status::cowboy:http_status(), Headers::cowboy:http_headers(), Req) -> {ok, Req}

url/1

url(Req) -> {undefined | binary(), Req}

version/1

version(Req) -> {cowboy:http_version(), Req}


Generated by EDoc, Oct 16 2014, 12:31:58.