xb5_trees_node (xb5 v1.0.1)

View Source

API for operating over xb5_trees internal nodes directly.

ℹ️ You're likely looking for xb5_trees.





























Summary

Types

elixir_reducer(Key, Value, ElemAcc)
elixir_reducer_acc(ElemAcc)
elixir_reducer_continuation(ElemAcc)
elixir_reducer_result(ElemAcc)
iter(Key, Value)
kv_pair(Key, Value)
t(Key, Value)
take_either_end_result(Key, Value)
take_key_result(Key, Value)

Functions

delete_att/2
elixir_reduce(Fun, Acc, Root)
foldl/3
foldr/3
from_orddict/2
get_att/4
insert_att/4
intersect(Size1, Root1, Size2, Root2)
intersect_with(Fun, Size1, Root1, Size2, Root2)
is_equal(Size1, Root1, Size2, Root2)
iterator/2
iterator_from/3
keys/1
larger/2
largest/1
map/2
merge(Size1, Root1, Size2, Root2)
merge_with(Fun, Size1, Root1, Size2, Root2)
new()
next/1
smaller/2
smallest/1
structural_stats(Root)
take_att/2
take_largest/1
take_smallest/1
to_list/1
to_rev_list/1
update_att/4
values/1

Types

elixir_reducer(Key, Value, ElemAcc)

-type elixir_reducer(Key, Value, ElemAcc) :: fun(({Key, Value}, ElemAcc) -> elixir_reducer_acc(ElemAcc)).

elixir_reducer_acc(ElemAcc)

-type elixir_reducer_acc(ElemAcc) :: {cont, ElemAcc} | {halt, ElemAcc} | {suspend, ElemAcc}.

elixir_reducer_continuation(ElemAcc)

-type elixir_reducer_continuation(ElemAcc) ::
          fun((elixir_reducer_acc(ElemAcc)) -> elixir_reducer_result(ElemAcc)).

elixir_reducer_result(ElemAcc)

-type elixir_reducer_result(ElemAcc) ::
          {done, ElemAcc} |
          {halted, ElemAcc} |
          {suspended, ElemAcc, elixir_reducer_continuation(ElemAcc)}.

iter(Key, Value)

-opaque iter(Key, Value)

kv_pair(Key, Value)

-type kv_pair(Key, Value) :: nonempty_improper_list(Key, Value).

t(Key, Value)

-opaque t(Key, Value)

take_either_end_result(Key, Value)

-type take_either_end_result(Key, Value) :: nonempty_improper_list(kv_pair(Key, Value), t(Key, Value)).

take_key_result(Key, Value)

-type take_key_result(Key, Value) :: nonempty_improper_list(Value, t(Key, Value)).

Functions

delete_att/2

-spec delete_att(Key, t(Key, Value)) -> badkey | t(Key, Value).

elixir_reduce(Fun, Acc, Root)

-spec elixir_reduce(Fun, Acc, Root) -> Result
                       when
                           Fun :: elixir_reducer(Key, Value, ElemAcc),
                           Acc :: elixir_reducer_acc(ElemAcc),
                           Root :: t(Key, Value),
                           Result :: elixir_reducer_result(ElemAcc).

foldl/3

-spec foldl(fun((Key, Value, Acc2) -> Acc1), Acc0, t(Key, Value)) -> AccN
               when Acc0 :: term(), Acc1 :: term(), Acc2 :: term(), AccN :: term().

foldr/3

-spec foldr(fun((Key, Value, Acc2) -> Acc1), Acc0, t(Key, Value)) -> AccN
               when Acc0 :: term(), Acc1 :: term(), Acc2 :: term(), AccN :: term().

from_orddict/2

-spec from_orddict(non_neg_integer(), orddict:orddict(Key, Value)) -> t(Key, Value).

get_att/4

-spec get_att(Key, t(Key, Value), fun((Key, Value) -> Found), fun((Key) -> NotFound) | unreachable) ->
                 Found | NotFound.

insert_att/4

-spec insert_att(Key, eager, Value, t(Key, Value)) -> key_exists | t(Key, Value);
                (Key, lazy, fun(() -> Value), t(Key, Value)) -> key_exists | t(Key, Value).

intersect(Size1, Root1, Size2, Root2)

-spec intersect(non_neg_integer(), t(KA, VA), non_neg_integer(), t(KB, VB)) ->
                   nonempty_improper_list(NewSize, t(KA | KB, VA | VB))
                   when NewSize :: non_neg_integer().

intersect_with(Fun, Size1, Root1, Size2, Root2)

-spec intersect_with(IntersectFun, non_neg_integer(), t(KA, VA), non_neg_integer(), t(KB, VB)) ->
                        nonempty_improper_list(NewSize, t(KA | KB, IntersectedV))
                        when
                            IntersectFun :: fun((KA | KB, VA, VB) -> IntersectedV),
                            NewSize :: non_neg_integer().

is_equal(Size1, Root1, Size2, Root2)

-spec is_equal(non_neg_integer(), t(_, _), non_neg_integer(), t(_, _)) -> boolean().

iterator/2

-spec iterator(t(Key, Value), ordered | reversed) -> iter(Key, Value).

iterator_from/3

-spec iterator_from(Key, t(Key, Value), ordered | reversed) -> iter(Key, Value).

keys/1

-spec keys(t(Key, _)) -> [Key].

larger/2

-spec larger(Key, t(Key, Value)) -> {Key, Value} | none.

largest/1

-spec largest(t(Key, Value)) -> {Key, Value}.

map/2

-spec map(fun((Key, Value) -> MappedValue), t(Key, Value)) -> t(Key, MappedValue).

merge(Size1, Root1, Size2, Root2)

-spec merge(non_neg_integer(), t(KA, VA), non_neg_integer(), t(KB, VB)) ->
               nonempty_improper_list(NewSize, t(KA | KB, VA | VB))
               when NewSize :: non_neg_integer().

merge_with(Fun, Size1, Root1, Size2, Root2)

-spec merge_with(MergeFun, non_neg_integer(), t(KA, VA), non_neg_integer(), t(KB, VB)) ->
                    nonempty_improper_list(NewSize, t(KA | KB, MergedV))
                    when MergeFun :: fun((KA | KB, VA, VB) -> MergedV), NewSize :: non_neg_integer().

new()

-spec new() -> t(term(), term()).

next/1

-spec next(iter(Key, Value)) -> {Key, Value, iter(Key, Value)} | none.

smaller/2

-spec smaller(Key, t(Key, Value)) -> {Key, Value} | none.

smallest/1

-spec smallest(t(Key, Value)) -> {Key, Value}.

structural_stats(Root)

-spec structural_stats(t(_, _)) -> xb5_structural_stats:t().

take_att/2

-spec take_att(Key, t(Key, Value)) -> badkey | take_key_result(Key, Value).

take_largest/1

-spec take_largest(t(Key, Value)) -> take_either_end_result(Key, Value).

take_smallest/1

-spec take_smallest(t(Key, Value)) -> take_either_end_result(Key, Value).

to_list/1

-spec to_list(t(Key, Value)) -> [{Key, Value}].

to_rev_list/1

-spec to_rev_list(t(Key, Value)) -> [{Key, Value}].

update_att/4

-spec update_att(Key, eager, Value, t(Key, _)) -> badkey | t(Key, Value);
                (Key, lazy, fun((PrevValue) -> Value), t(Key, PrevValue)) -> badkey | t(Key, Value).

values/1

-spec values(t(_, Value)) -> [Value].