Module rt_gfrtchord

client_key() = [unicode_char()]

custom_info() = undefined | term()

custom_message() = {get_rt, SourcePID :: comm:mypid()}
                 | {get_rt_reply, RT :: rt()}
                 | {trigger_random_lookup}
                 | {rt_get_node, From :: comm:mypid()}
                 | {rt_learn_node, NewNode :: node:node_type()}

entry_type() = normal | source | sticky

external_rt() = 
    {Size :: unknown | float(), external_rt_t_tree()}

external_rt_t_tree() = 
    gb_trees:tree(NodeId :: key(), Node :: node:node_type())

key() = rt_chord:key()

rt_entry() = 
    #rt_entry{node = undefined | node:node_type(),
              type = undefined | entry_type(),
              adjacent_fingers =
                  {key() | undefined, key() | undefined},
              custom = custom_info()}

rt_entry_info_t() = #rt_entry_info{group = other_dc | same_dc}

unicode_char() = 0..55295 | 57344..65533 | 65536..1114111

client_key_to_binary(Key :: client_key()) -> binary()

init(Neighbors :: nodelist:neighborhood()) -> rt()

hash_key(Key :: client_key() | binary()) -> key()

get_random_node_id() -> key()

init_stabilize(Neighbors :: nodelist:neighborhood(), RT :: rt()) ->
                  rt()

update(OldRT :: rt(),
       OldNeighbors :: nodelist:neighborhood(),
       NewNeighbors :: nodelist:neighborhood()) ->
          {trigger_rebuild, rt()} | {ok, rt()}

filter_dead_node(RT :: rt(),
                 DeadPid :: comm:mypid(),
                 Reason :: fd:reason()) ->
                    rt()

to_pid_list(RT :: rt()) -> [comm:mypid()]

get_size(Rt_t :: rt() | external_rt()) -> non_neg_integer()

n() -> 340282366920938463463374607431768211456

get_range(Begin :: key(),
          End :: key() | 340282366920938463463374607431768211456) ->
             number()

get_split_key(Begin :: key(),
              End :: key()
                   | 340282366920938463463374607431768211456,
              SplitFraction ::
                  {Num :: non_neg_integer(),
                   Denom :: pos_integer()}) ->
                 key() | 340282366920938463463374607431768211456

get_split_keys(Begin :: key(),
               End :: key()
                    | 340282366920938463463374607431768211456,
               Parts :: pos_integer()) ->
                  [key()]

get_random_in_interval(SimpleI :: intervals:simple_interval2()) ->
                          key()

get_random_in_interval(SimpleI :: intervals:simple_interval2(),
                       Count :: pos_integer()) ->
                          [key(), ...]

get_replica_keys(Key :: key()) -> [key()]

get_key_segment(Key :: key()) -> pos_integer()

dump(RT :: rt()) ->
        KeyValueList :: [{Index :: string(), Node :: string()}]

dump_to_csv(RT :: rt()) -> [char()]

check_config() -> boolean()

get_random_key_from_generator(SourceNodeId :: key(),
                              PredId :: key(),
                              SuccId :: key()) ->
                                 key()

handle_custom_message(Message :: custom_message(),
                      State :: rt_loop:state_active()) ->
                         rt_loop:state_active() | unknown_event

check(OldRT :: rt(),
      NewRT :: rt(),
      Neighbors :: nodelist:neighborhood(),
      ReportToFD :: boolean()) ->
         ok

check(OldRT :: rt(),
      NewRT :: rt(),
      OldNeighbors :: nodelist:neighborhood(),
      NewNeighbors :: nodelist:neighborhood(),
      ReportToFD :: boolean()) ->
         ok

empty_ext(Neighbors :: nodelist:neighborhood()) -> external_rt()

next_hop(State :: dht_node_state:state(), Id :: key()) ->
            {succ | other, comm:mypid()}

export_rt_to_dht_node(RT :: rt(),
                      Neighbors :: nodelist:neighborhood()) ->
                         external_rt()

to_list(State :: dht_node_state:state()) -> nodelist:snodelist()

get_source_node(RT :: rt()) -> rt_entry()

get_source_id(RT :: rt()) -> key()

check_rt_integrity(RT :: rt()) -> boolean()

wrap_message(Key :: key(),
             Msg :: comm:message(),
             State :: dht_node_state:state(),
             Hops :: non_neg_integer()) ->
                {'$wrapped', comm:mypid(), comm:message()} |
                comm:message()

unwrap_message(Msg :: comm:message(),
               State :: dht_node_state:state()) ->
                  comm:message()

check_well_connectedness(RT :: rt()) -> boolean()

allowed_nodes(RT :: rt()) -> [rt_entry()]

rt_entry_info(Node :: node:node_type(),
              Type :: entry_type(),
              PredId :: key(),
              SuccId :: key()) ->
                 rt_entry_info_t()

frt_check_config() -> boolean()