Mnemonix v0.2.0 Mnemonix.Store.Behaviour behaviour

Required and optional functions Mnemonix.Store adapters must implement.

Optional callbacks have default implementations in terms of the required ones, but are overridable so that adapters can offer optimized versions where possible.

Summary

Callbacks

delete(store, key)

Removes the entry under key in store

fetch(store, key)

Retrievs the value of the entry under key in store

fetch!(store, key)

Fetches the value for specific key

get(store, key)

Gets the value for a specific key

get(store, key, value)

Gets the value for a specific key with default

get_and_update(store, key, list)

Gets the value from key and updates it, all in one pass

get_and_update!(store, key, list)

Gets the value from key and updates it. Raises if there is no key

get_lazy(store, key, list)

Gets the value for a specific key

has_key?(store, key)

Returns whether a given key exists in the given store

init(arg0)

Prepares the underlying store type for usage with supplied options

pop(store, key)

Returns and removes the value associated with key in store

pop(store, key, value)

Returns and removes the value associated with key in store with default

pop_lazy(store, key, list)

Lazily returns and removes the value associated with key in store

put(store, key, value)

Creates a new entry for value under key in store

put_new(store, key, value)

Puts the given value under key unless the entry key already exists

put_new_lazy(store, key, list)

Evaluates fun and puts the result under key in store unless key is already present

teardown(reason, store)

update(store, key, value, list)

Updates the key in store with the given function

update!(store, key, list)

Updates the key with the given function

Callbacks

delete(store, key)

delete(store, key) ::
  {:ok, store} |
  {:raise, exception, info}

Removes the entry under key in store.

If the key does not exist, the contents of store will be unaffected.

fetch(store, key)

fetch(store, key) ::
  {:ok, store, value} |
  {:raise, exception, info}

Retrievs the value of the entry under key in store.

If the key does not exist, returns :error, otherwise returns {:ok, value}.

fetch!(store, key) (optional)

fetch!(store, key) ::
  {:ok, store, value} |
  {:raise, exception, info}

Fetches the value for specific key.

If key does not exist, triggers a KeyError.

get(store, key) (optional)

get(store, key) ::
  {:ok, store, value} |
  {:raise, exception, info}

Gets the value for a specific key.

If key does not exist, returns nil.

get(store, key, value) (optional)

get(store, key, value) ::
  {:ok, store, value} |
  {:raise, exception, info}

Gets the value for a specific key with default.

If key does not exist, returns default.

get_and_update(store, key, list) (optional)

get_and_update(store, key, (... -> any)) ::
  {:ok, store, value} |
  {:raise, exception, info}

Gets the value from key and updates it, all in one pass.

This fun argument receives the value of key (or nil if key is not present) and must return a two-element tuple: the “get” value (the retrieved value, which can be operated on before being returned) and the new value to be stored under key. The fun may also return :pop, implying the current value shall be removed from store and returned.

The returned value is a tuple with the “get” value returned by fun and a reference to the store with the updated value under key.

get_and_update!(store, key, list) (optional)

get_and_update!(store, key, (... -> any)) ::
  {:ok, store, value} |
  {:raise, exception, info}

Gets the value from key and updates it. Raises if there is no key.

This fun argument receives the value of key and must return a two-element tuple: the “get” value (the retrieved value, which can be operated on before being returned) and the new value to be stored under key.

The returned value is a tuple with the “get” value returned by fun and a a reference to the store with the updated value under key.

get_lazy(store, key, list) (optional)

get_lazy(store, key, (... -> any)) ::
  {:ok, store, value} |
  {:raise, exception, info}

Gets the value for a specific key.

If key does not exist, lazily evaluates fun and returns its result.

This is useful if the default value is very expensive to calculate or generally difficult to setup and teardown again.

has_key?(store, key) (optional)

has_key?(store, key) ::
  {:ok, store, boolean} |
  {:raise, exception, info}

Returns whether a given key exists in the given store.

init(arg0)

init(Mnemonix.Store.opts) ::
  {:ok, Mnemonix.Store.state} |
  {:ok, Mnemonix.Store.state, timeout | :hibernate} |
  :ignore |
  {:stop, reason :: term}

Prepares the underlying store type for usage with supplied options.

Returns internal state the adapter can use to access the underlying store to perform operations on data.

pop(store, key) (optional)

pop(store, key) ::
  {:ok, store, value} |
  {:raise, exception, info}

Returns and removes the value associated with key in store.

If no value is associated with the key, nil is returned.

pop(store, key, value) (optional)

pop(store, key, value) ::
  {:ok, store, value} |
  {:raise, exception, info}

Returns and removes the value associated with key in store with default.

If no value is associated with the key but default is given, that will be returned instead without touching the store.

pop_lazy(store, key, list) (optional)

pop_lazy(store, key, (... -> any)) ::
  {:ok, store, value} |
  {:raise, exception, info}

Lazily returns and removes the value associated with key in store.

This is useful if the default value is very expensive to calculate or generally difficult to setup and teardown again.

put(store, key, value)

put(store, key, value) ::
  {:ok, store} |
  {:raise, exception, info}

Creates a new entry for value under key in store.

put_new(store, key, value) (optional)

put_new(store, key, value) ::
  {:ok, store} |
  {:raise, exception, info}

Puts the given value under key unless the entry key already exists.

put_new_lazy(store, key, list) (optional)

put_new_lazy(store, key, (... -> any)) ::
  {:ok, store} |
  {:raise, exception, info}

Evaluates fun and puts the result under key in store unless key is already present.

This is useful if the value is very expensive to calculate or generally difficult to setup and teardown again.

teardown(reason, store)

teardown(reason, store) ::
  {:ok, reason} |
  {:error, reason} when reason: :normal | :shutdown | {:shutdown, term} | term

update(store, key, value, list) (optional)

update(store, key, value, (... -> any)) ::
  {:ok, store} |
  {:raise, exception, info}

Updates the key in store with the given function.

If the key does not exist, inserts the given initial value.

update!(store, key, list) (optional)

update!(store, key, (... -> any)) ::
  {:ok, store} |
  {:raise, exception, info}

Updates the key with the given function.

If the key does not exist, triggers a KeyError.