memcache

v0.1.3

memcache v0.1.3 Memcache

Binary protocol client for Memcached server.

Link to this section Summary

Types

key()
opts()
value()

Functions

add(key, value, opts \\ [])

Sets value for given key only if it does not already exist

decrement(key, amount, opts \\ [])

Decrements a counter on given key

delete(key)

Deletes the value for the given key

fetch(key, missing_fn, opts \\ [])
fetch!(key, missing_fn, opts \\ [])
flush(opts \\ [])

Flushes the cache

get(key, opts \\ [])

Gets value for given key

get!(key, opts \\ [])
increment(key, amount, opts \\ [])

Increments a counter on given key

mget(keys, opts \\ [])

Gets values for multiple keys with a single pipelined operation

mset(keyvalues, opts \\ [])

Sets multiple values with a single pipelined operation. Value needs to be a tuple of key and value

replace(key, value, opts \\ [])

Sets valuefor given key only if it already exists

set(key, value, opts \\ [])

Sets value for given key

start(type, args)

Called when an application is started

version()

Returns the current memcached version

Link to this section Types

Link to this type key() 
key() :: binary()
Link to this type opts() 
opts() :: Keyword.t()
Link to this type value() 
value() :: any()

Link to this section Functions

Link to this function add(key, value, opts \\ []) 
add(key(), value(), opts()) :: Memcache.Response.t()

Sets value for given key only if it does not already exist.

Link to this function decrement(key, amount, opts \\ []) 
decrement(key(), pos_integer(), opts()) :: Memcache.Response.t()

Decrements a counter on given key.

Link to this function delete(key) 
delete(key()) :: Memcache.Response.t()

Deletes the value for the given key.

Link to this function fetch(key, missing_fn, opts \\ [])
Link to this function fetch!(key, missing_fn, opts \\ [])
Link to this function flush(opts \\ []) 
flush(opts()) :: Memcache.Response.t()

Flushes the cache.

Link to this function get(key, opts \\ []) 
get(key(), opts()) :: Memcache.Response.t()

Gets value for given key.

Link to this function get!(key, opts \\ [])
Link to this function increment(key, amount, opts \\ []) 
increment(key(), pos_integer(), opts()) :: Memcache.Response.t()

Increments a counter on given key.

Link to this function mget(keys, opts \\ []) 
mget(Enumerable.t(), opts()) :: Stream.t()

Gets values for multiple keys with a single pipelined operation.

Link to this function mset(keyvalues, opts \\ []) 
mset(Enumerable.t(), opts()) :: Stream.t()

Sets multiple values with a single pipelined operation. Value needs to be a tuple of key and value.

Link to this function replace(key, value, opts \\ []) 
replace(key(), value(), opts()) :: Memcache.Response.t()

Sets valuefor given key only if it already exists.

Link to this function set(key, value, opts \\ []) 
set(key(), value(), opts()) :: Memcache.Response.t()

Sets value for given key.

Link to this function start(type, args)

Called when an application is started.

This function is called when an application is started using Application.start/2 (and functions on top of that, such as Application.ensure_started/2). This function should start the top-level process of the application (which should be the top supervisor of the application’s supervision tree if the application follows the OTP design principles around supervision).

start_type defines how the application is started:

  • :normal - used if the startup is a normal startup or if the application is distributed and is started on the current node because of a failover from another node and the application specification key :start_phases is :undefined.
  • {:takeover, node} - used if the application is distributed and is started on the current node because of a failover on the node node.
  • {:failover, node} - used if the application is distributed and is started on the current node because of a failover on node node, and the application specification key :start_phases is not :undefined.

start_args are the arguments passed to the application in the :mod specification key (e.g., mod: {MyApp, [:my_args]}).

This function should either return {:ok, pid} or {:ok, pid, state} if startup is successful. pid should be the PID of the top supervisor. state can be an arbitrary term, and if omitted will default to []; if the application is later stopped, state is passed to the stop/1 callback (see the documentation for the c:stop/1 callback for more information).

use Application provides no default implementation for the start/2 callback.

Callback implementation for Application.start/2.

Link to this function version() 
version() :: Memcache.Response.t()

Returns the current memcached version.