anchor (anchor v0.3.9)

View Source

Summary

Types

error/0
error_reason/0
option/0
options/0
response/0

Functions

add(Key, Value)
add(Key, Value, TTL)
add(Key, Value, TTL, Timeout)
async_add(Key, Value)
async_add(Key, Value, TTL)
async_add(Key, Value, TTL, Pid)
async_add(Key, Value, TTL, Pid, Timeout)
async_decrement(Key)
async_decrement(Key, Amount)
async_decrement(Key, Amount, InitialValue)
async_decrement(Key, Amount, InitialValue, TTL)
async_decrement(Key, Amount, InitialValue, TTL, Pid)
async_decrement(Key, Amount, InitialValue, TTL, Pid, Timeout)
async_delete(Key)
async_delete(Key, Pid)
async_delete(Key, Pid, Timeout)
async_flush()
async_flush(TTL)
async_flush(TTL, Pid)
async_flush(TTL, Pid, Timeout)
async_get(Key)
async_get(Key, Pid)
async_get(Key, Pid, Timeout)
async_increment(Key)
async_increment(Key, Amount)
async_increment(Key, Amount, InitialValue)
async_increment(Key, Amount, InitialValue, TTL)
async_increment(Key, Amount, InitialValue, TTL, Pid)
async_increment(Key, Amount, InitialValue, TTL, Pid, Timeout)
async_noop()
async_noop(Pid)
async_noop(Pid, Timeout)
async_quit()
async_quit(Pid)
async_quit(Pid, Timeout)
async_replace(Key, Value)
async_replace(Key, Value, TTL)
async_replace(Key, Value, TTL, Pid)
async_replace(Key, Value, TTL, Pid, Timeout)
async_set(Key, Value)
async_set(Key, Value, TTL)
async_set(Key, Value, TTL, Pid)
async_set(Key, Value, TTL, Pid, Timeout)
async_version()
async_version(Pid)
async_version(Pid, Timeout)
decrement(Key)
decrement(Key, Amount)
decrement(Key, Amount, InitialValue)
decrement(Key, Amount, InitialValue, TTL)
decrement(Key, Amount, InitialValue, TTL, Timeout)
delete(Key)
delete(Key, Timeout)
flush()
flush(TTL)
flush(TTL, Timeout)
get(Key)
get(Key, Timeout)
increment(Key)
increment(Key, Amount)
increment(Key, Amount, InitialValue)
increment(Key, Amount, InitialValue, TTL)
increment(Key, Amount, InitialValue, TTL, Timeout)
noop()
noop(Timeout)
quit()
quit(Timeout)
receive_response(RequestId)
replace(Key, Value)
replace(Key, Value, TTL)
replace(Key, Value, TTL, Timeout)
response(_)
set(Key, Value)
set(Key, Value, TTL)
set(Key, Value, TTL, Timeout)
version()
version(Timeout)

Types

error/0

-type error() :: {error, error_reason()}.

error_reason/0

-type error_reason() ::
          auth_continue | auth_error | busy | incr_non_numeric | internal_error | invalid_args |
          item_not_stored | key_exists | key_not_found | not_supported | out_of_memory | temp_failure |
          unknown_command | value_too_large | vbucket_error | no_server | pool_not_started |
          shackle_not_started | timeout.

option/0

-type option() :: {async, pid()}.

options/0

-type options() :: [option()].

response/0

-type response() ::
          #response{op_code :: non_neg_integer() | undefined,
                    key_length :: non_neg_integer() | undefined,
                    extras_length :: non_neg_integer() | undefined,
                    data_type :: non_neg_integer() | undefined,
                    status :: non_neg_integer() | undefined,
                    body_length :: non_neg_integer() | undefined,
                    opaque :: non_neg_integer() | undefined,
                    cas :: non_neg_integer() | undefined,
                    extras :: binary() | undefined,
                    key :: binary() | undefined,
                    value :: binary() | undefined}.

Functions

add(Key, Value)

-spec add(binary(), binary()) -> ok | error().

add(Key, Value, TTL)

-spec add(binary(), binary(), non_neg_integer()) -> ok | error().

add(Key, Value, TTL, Timeout)

-spec add(binary(), binary(), non_neg_integer(), pos_integer()) -> ok | error().

async_add(Key, Value)

-spec async_add(binary(), binary()) -> {ok, shackle:request_id()} | error().

async_add(Key, Value, TTL)

-spec async_add(binary(), binary(), non_neg_integer()) -> {ok, shackle:request_id()} | error().

async_add(Key, Value, TTL, Pid)

-spec async_add(binary(), binary(), non_neg_integer(), pid()) -> {ok, shackle:request_id()} | error().

async_add(Key, Value, TTL, Pid, Timeout)

-spec async_add(binary(), binary(), non_neg_integer(), pid(), timeout()) ->
                   {ok, shackle:request_id()} | error().

async_decrement(Key)

-spec async_decrement(binary()) -> {ok, shackle:request_id()} | error().

async_decrement(Key, Amount)

-spec async_decrement(binary(), integer()) -> {ok, shackle:request_id()} | error().

async_decrement(Key, Amount, InitialValue)

-spec async_decrement(binary(), integer(), integer()) -> {ok, shackle:request_id()} | error().

async_decrement(Key, Amount, InitialValue, TTL)

-spec async_decrement(binary(), integer(), integer(), non_neg_integer()) ->
                         {ok, shackle:request_id()} | error().

async_decrement(Key, Amount, InitialValue, TTL, Pid)

-spec async_decrement(binary(), integer(), integer(), non_neg_integer(), pid()) ->
                         {ok, shackle:request_id()} | error().

async_decrement(Key, Amount, InitialValue, TTL, Pid, Timeout)

-spec async_decrement(binary(), integer(), integer(), non_neg_integer(), pid(), timeout()) ->
                         {ok, shackle:request_id()} | error().

async_delete(Key)

-spec async_delete(binary()) -> {ok, shackle:request_id()} | error().

async_delete(Key, Pid)

-spec async_delete(binary(), pid()) -> {ok, shackle:request_id()} | error().

async_delete(Key, Pid, Timeout)

-spec async_delete(binary(), pid(), timeout()) -> {ok, shackle:request_id()} | error().

async_flush()

-spec async_flush() -> {ok, shackle:request_id()} | error().

async_flush(TTL)

-spec async_flush(non_neg_integer()) -> {ok, shackle:request_id()} | error().

async_flush(TTL, Pid)

-spec async_flush(non_neg_integer(), pid()) -> {ok, shackle:request_id()} | error().

async_flush(TTL, Pid, Timeout)

-spec async_flush(non_neg_integer(), pid(), timeout()) -> {ok, shackle:request_id()} | error().

async_get(Key)

-spec async_get(binary()) -> {ok, shackle:request_id()} | error().

async_get(Key, Pid)

-spec async_get(binary(), pid()) -> {ok, shackle:request_id()} | error().

async_get(Key, Pid, Timeout)

-spec async_get(binary(), pid(), timeout()) -> {ok, shackle:request_id()} | error().

async_increment(Key)

-spec async_increment(binary()) -> {ok, shackle:request_id()} | error().

async_increment(Key, Amount)

-spec async_increment(binary(), integer()) -> {ok, shackle:request_id()} | error().

async_increment(Key, Amount, InitialValue)

-spec async_increment(binary(), integer(), integer()) -> {ok, shackle:request_id()} | error().

async_increment(Key, Amount, InitialValue, TTL)

-spec async_increment(binary(), integer(), integer(), non_neg_integer()) ->
                         {ok, shackle:request_id()} | error().

async_increment(Key, Amount, InitialValue, TTL, Pid)

-spec async_increment(binary(), integer(), integer(), non_neg_integer(), pid()) ->
                         {ok, shackle:request_id()} | error().

async_increment(Key, Amount, InitialValue, TTL, Pid, Timeout)

-spec async_increment(binary(), integer(), integer(), non_neg_integer(), pid(), timeout()) ->
                         {ok, shackle:request_id()} | error().

async_noop()

-spec async_noop() -> {ok, shackle:request_id()} | error().

async_noop(Pid)

-spec async_noop(pid()) -> {ok, shackle:request_id()} | error().

async_noop(Pid, Timeout)

-spec async_noop(pid(), timeout()) -> {ok, shackle:request_id()} | error().

async_quit()

-spec async_quit() -> {ok, shackle:request_id()} | error().

async_quit(Pid)

-spec async_quit(pid()) -> {ok, shackle:request_id()} | error().

async_quit(Pid, Timeout)

-spec async_quit(pid(), timeout()) -> {ok, shackle:request_id()} | error().

async_replace(Key, Value)

-spec async_replace(binary(), binary()) -> {ok, shackle:request_id()} | error().

async_replace(Key, Value, TTL)

-spec async_replace(binary(), binary(), non_neg_integer()) -> {ok, shackle:request_id()} | error().

async_replace(Key, Value, TTL, Pid)

-spec async_replace(binary(), binary(), non_neg_integer(), pid()) ->
                       {ok, shackle:request_id()} | error().

async_replace(Key, Value, TTL, Pid, Timeout)

-spec async_replace(binary(), binary(), non_neg_integer(), pid(), timeout()) ->
                       {ok, shackle:request_id()} | error().

async_set(Key, Value)

-spec async_set(binary(), binary()) -> {ok, shackle:request_id()} | error().

async_set(Key, Value, TTL)

-spec async_set(binary(), binary(), non_neg_integer()) -> {ok, shackle:request_id()} | error().

async_set(Key, Value, TTL, Pid)

-spec async_set(binary(), binary(), non_neg_integer(), pid()) -> {ok, shackle:request_id()} | error().

async_set(Key, Value, TTL, Pid, Timeout)

-spec async_set(binary(), binary(), non_neg_integer(), pid(), timeout()) ->
                   {ok, shackle:request_id()} | error().

async_version()

-spec async_version() -> {ok, shackle:request_id()} | error().

async_version(Pid)

-spec async_version(pid()) -> {ok, shackle:request_id()} | error().

async_version(Pid, Timeout)

-spec async_version(pid(), timeout()) -> {ok, shackle:request_id()} | error().

decrement(Key)

-spec decrement(binary()) -> {ok, integer()} | error().

decrement(Key, Amount)

-spec decrement(binary(), integer()) -> {ok, integer()} | error().

decrement(Key, Amount, InitialValue)

-spec decrement(binary(), integer(), integer()) -> {ok, integer()} | error().

decrement(Key, Amount, InitialValue, TTL)

-spec decrement(binary(), integer(), integer(), non_neg_integer()) -> {ok, integer()} | error().

decrement(Key, Amount, InitialValue, TTL, Timeout)

-spec decrement(binary(), integer(), integer(), non_neg_integer(), pos_integer()) ->
                   {ok, integer()} | error().

delete(Key)

-spec delete(binary()) -> ok | error().

delete(Key, Timeout)

-spec delete(binary(), pos_integer()) -> ok | error().

flush()

-spec flush() -> ok | error().

flush(TTL)

-spec flush(non_neg_integer()) -> ok | error().

flush(TTL, Timeout)

-spec flush(non_neg_integer(), pos_integer()) -> ok | error().

get(Key)

-spec get(binary()) -> {ok, binary()} | error().

get(Key, Timeout)

-spec get(binary(), pos_integer()) -> {ok, binary()} | error().

increment(Key)

-spec increment(binary()) -> {ok, integer()} | error().

increment(Key, Amount)

-spec increment(binary(), integer()) -> {ok, integer()} | error().

increment(Key, Amount, InitialValue)

-spec increment(binary(), integer(), integer()) -> {ok, integer()} | error().

increment(Key, Amount, InitialValue, TTL)

-spec increment(binary(), integer(), integer(), non_neg_integer()) -> {ok, integer()} | error().

increment(Key, Amount, InitialValue, TTL, Timeout)

-spec increment(binary(), integer(), integer(), non_neg_integer(), pos_integer()) ->
                   {ok, integer()} | error().

noop()

-spec noop() -> ok | error().

noop(Timeout)

-spec noop(pos_integer()) -> ok | error().

quit()

-spec quit() -> ok | error().

quit(Timeout)

-spec quit(pos_integer()) -> ok | error().

receive_response(RequestId)

-spec receive_response(shackle:request_id()) -> {ok, term()} | {error, term()}.

replace(Key, Value)

-spec replace(binary(), binary()) -> ok | error().

replace(Key, Value, TTL)

-spec replace(binary(), binary(), non_neg_integer()) -> ok | error().

replace(Key, Value, TTL, Timeout)

-spec replace(binary(), binary(), non_neg_integer(), pos_integer()) -> ok | error().

response(_)

-spec response({ok, term()} | error()) -> ok | {ok, term()} | error().

set(Key, Value)

-spec set(binary(), binary()) -> ok | error().

set(Key, Value, TTL)

-spec set(binary(), binary(), non_neg_integer()) -> ok | error().

set(Key, Value, TTL, Timeout)

-spec set(binary(), binary(), non_neg_integer(), pos_integer()) -> ok | error().

version()

-spec version() -> {ok, binary()} | error().

version(Timeout)

-spec version(pos_integer()) -> {ok, binary()} | error().