Solve.Lookup behaviour (Solve v0.2.1)

Copy Markdown View Source

Process-local facade for interacting with a Solve app.

Summary

Types

target()

@type target() :: Solve.controller_target()

Callbacks

handle_solve_updated(map, term)

(optional)
@callback handle_solve_updated(map(), term()) :: {:ok, term()}

Functions

collection(controller_name)

@spec collection(atom()) :: Solve.Collection.t(map())

collection(app, controller_name)

@spec collection(GenServer.server() | nil, atom()) :: Solve.Collection.t(map())

dispatch(controller_name, event)

@spec dispatch(target(), atom()) :: :ok

dispatch(controller_name, event, payload)

@spec dispatch(target(), atom(), term()) :: :ok

dispatch(app, controller_name, event, payload)

@spec dispatch(GenServer.server() | nil, target(), atom(), term()) :: :ok

event(controller, event_name)

@spec event(map() | nil | Solve.Collection.t(any()), atom()) :: {pid(), term()} | nil

Reads one direct {pid, message} event tuple from a lookup item.

This is a convenience wrapper over events(controller)[event_name].

event(controller, event_name, payload)

@spec event(map() | nil | Solve.Collection.t(any()), atom(), term()) ::
  {pid(), term()} | nil

Builds a direct {pid, message} event tuple with a fixed payload for a lookup item.

events(arg1)

@spec events(map() | nil | Solve.Collection.t(any())) :: map() | nil

handle_message(message)

@spec handle_message(Solve.Message.t()) :: map()

solve(controller_name)

@spec solve(target()) :: map() | nil

solve(app, controller_name)

@spec solve(GenServer.server() | nil, target()) :: map() | nil