tai v0.0.43 Tai.Venues.AssetBalances

Link to this section Summary

Functions

Returns a specification to start this module under a supervisor.

Invoked to handle `continue` instructions.

Invoked when the server is started. `start_link/3` or `start/3` will block until it returns.

Link to this section Types

Link to this type

account_id()

account_id() :: Tai.Venues.Adapter.account_id()
Link to this type

asset_balance()

asset_balance() :: Tai.Venues.AssetBalance.t()
Link to this type

lock_result()

lock_result() ::
  {:ok, Decimal.t()}
  | {:error,
     :not_found
     | :insufficient_balance
     | :min_greater_than_max
     | :min_less_than_zero}
Link to this type

modify_result()

modify_result() ::
  {:ok, asset_balance()} | {:error, :not_found | :value_must_be_positive}
Link to this type

unlock_request()

Link to this type

unlock_result()

unlock_result() :: :ok | {:error, :insufficient_balance | term()}

Link to this section Functions

Link to this function

add(venue_id, account_id, asset, val)

add(
  venue_id(),
  account_id(),
  asset(),
  val :: number() | String.t() | Decimal.t()
) :: modify_result()
Link to this function

child_spec(init_arg)

Returns a specification to start this module under a supervisor.

See `Supervisor`.

Link to this function

find_by(filters)

find_by(filters :: [...]) :: {:ok, asset_balance()} | {:error, :not_found}
Link to this function

handle_continue(arg, state)

Invoked to handle `continue` instructions.

It is useful for performing work after initialization or for splitting the work in a callback in multiple steps, updating the process state along the way.

Return values are the same as `c:handle_cast/2`.

This callback is optional. If one is not implemented, the server will fail if a continue instruction is used.

This callback is only supported on Erlang/OTP 21+.

Callback implementation for `GenServer.handle_continue/2`.

Invoked when the server is started. `start_link/3` or `start/3` will block until it returns.

`init_arg` is the argument term (second argument) passed to `start_link/3`.

Returning `{:ok, state}` will cause `start_link/3` to return `{:ok, pid}` and the process to enter its loop.

Returning `{:ok, state, timeout}` is similar to `{:ok, state}`, except that it also sets a timeout. See the "Timeouts" section in the module documentation for more information.

Returning `{:ok, state, :hibernate}` is similar to `{:ok, state}` except the process is hibernated before entering the loop. See `c:handle_call/3` for more information on hibernation.

Returning `{:ok, state, {:continue, continue}}` is similar to `{:ok, state}` except that immediately after entering the loop the `c:handle_continue/2` callback will be invoked with the value `continue` as first argument.

Returning `:ignore` will cause `start_link/3` to return `:ignore` and the process will exit normally without entering the loop or calling `c:terminate/2`. If used when part of a supervision tree the parent supervisor will not fail to start nor immediately try to restart the `GenServer`. The remainder of the supervision tree will be started and so the `GenServer` should not be required by other processes. It can be started later with `Supervisor.restart_child/2` as the child specification is saved in the parent supervisor. The main use cases for this are:

  • The `GenServer` is disabled by configuration but might be enabled later.
  • An error occurred and it will be handled by a different mechanism than the `Supervisor`. Likely this approach involves calling `Supervisor.restart_child/2` after a delay to attempt a restart.

Returning `{:stop, reason}` will cause `start_link/3` to return `{:error, reason}` and the process to exit with reason `reason` without entering the loop or calling `c:terminate/2`.

Callback implementation for `GenServer.init/1`.

Link to this function

lock(lock_request)

lock(lock_request()) :: lock_result()
Link to this function

sub(venue_id, account_id, asset, val)

sub(
  venue_id(),
  account_id(),
  asset(),
  val :: number() | String.t() | Decimal.t()
) :: modify_result()
Link to this function

unlock(unlock_request)

unlock(unlock_request()) :: unlock_result()
Link to this function

upsert(balance)

upsert(asset_balance()) :: :ok
Link to this function

where(filters)

where(filters :: [...]) :: [asset_balance()]