BowlineClient.Read (bowline_client v1.2.0)

Copy Markdown View Source

Decoding helpers used by generated from_map/1 functions; each raises ArgumentError naming the key on a shape mismatch.

Summary

Functions

big_int(map, key)
big_int_value(value, key)
bool(map, key)
bool_value(value, key)
bytes(map, key)
bytes_value(value, key)
float(map, key)
float_value(value, key)
int(map, key)
int_value(value, key)
list(map, key, decode)
list_value(value, key, decode)
map(map, key, decode)
map_value(value, key, decode)
mismatch(key, expected, value)
object(value, key)
optional(map, key, decode)
optional_value(value, decode)
parse_timestamp(value, key \\ "timestamp")
prefixed(prefix, issues)
raw(map, key)
string(map, key)
string_value(value, key)
timestamp(map, key)
timestamp_value(value, key)
validate_list(path, items, validate)
validate_map(path, entries, validate)
validate_optional(value, validate)

Functions

big_int(map, key)

@spec big_int(map(), String.t()) :: integer()

big_int_value(value, key)

@spec big_int_value(term(), String.t()) :: integer()

bool(map, key)

@spec bool(map(), String.t()) :: boolean()

bool_value(value, key)

@spec bool_value(term(), String.t()) :: boolean()

bytes(map, key)

@spec bytes(map(), String.t()) :: binary()

bytes_value(value, key)

@spec bytes_value(term(), String.t()) :: binary()

float(map, key)

@spec float(map(), String.t()) :: float()

float_value(value, key)

@spec float_value(term(), String.t()) :: float()

int(map, key)

@spec int(map(), String.t()) :: integer()

int_value(value, key)

@spec int_value(term(), String.t()) :: integer()

list(map, key, decode)

@spec list(map(), String.t(), (term() -> item)) :: [item] when item: term()

list_value(value, key, decode)

@spec list_value(term(), String.t(), (term() -> item)) :: [item] when item: term()

map(map, key, decode)

@spec map(map(), String.t(), (term() -> value)) :: %{required(String.t()) => value}
when value: term()

map_value(value, key, decode)

@spec map_value(term(), String.t(), (term() -> value)) :: %{
  required(String.t()) => value
}
when value: term()

mismatch(key, expected, value)

@spec mismatch(String.t(), String.t(), term()) :: no_return()

object(value, key)

@spec object(term(), String.t()) :: map()

optional(map, key, decode)

@spec optional(map(), String.t(), (term() -> value)) :: value | nil when value: term()

optional_value(value, decode)

@spec optional_value(term(), (term() -> value)) :: value | nil when value: term()

parse_timestamp(value, key \\ "timestamp")

@spec parse_timestamp(String.t(), String.t()) :: DateTime.t()

prefixed(prefix, issues)

@spec prefixed([String.t()], [BowlineClient.Issue.t()]) :: [BowlineClient.Issue.t()]

raw(map, key)

@spec raw(map(), String.t()) :: term()

string(map, key)

@spec string(map(), String.t()) :: String.t()

string_value(value, key)

@spec string_value(term(), String.t()) :: String.t()

timestamp(map, key)

@spec timestamp(map(), String.t()) :: DateTime.t()

timestamp_value(value, key)

@spec timestamp_value(term(), String.t()) :: DateTime.t()

validate_list(path, items, validate)

@spec validate_list([String.t()], [term()] | nil, (term() ->
                                               [BowlineClient.Issue.t()])) :: [
  BowlineClient.Issue.t()
]

validate_map(path, entries, validate)

@spec validate_map([String.t()], map() | nil, (term() -> [BowlineClient.Issue.t()])) ::
  [
    BowlineClient.Issue.t()
  ]

validate_optional(value, validate)

@spec validate_optional(term(), (term() -> [BowlineClient.Issue.t()])) :: [
  BowlineClient.Issue.t()
]