anchor.diff:  get_sticky_entries(#rt_t{nodes=Nodes}) ->
       util:gb_trees_foldl(fun(_K, #rt_entry{type=sticky} = E, Acc) -> [E|Acc];
                         (_,_,Acc) -> Acc
  -                  end, [], Nodes)
  -    .
  +                  end, [], Nodes).
   
   % @doc Check if a node exists in the routing table
   -spec entry_exists(EntryKey :: key(), rt()) -> boolean().
  
positive.code: create_entry(Node, Type, RT) ->
      NodeId = node:id(Node),
      Tree = get_rt_tree(RT),
      % search the adjacent fingers using the routing table
      PredLookup = util:gb_trees_largest_smaller_than(NodeId, Tree),
      RTSize = get_size(RT),
      case PredLookup of
          nil when RTSize =:= 0 -> % this is the first entry of the RT
              NewEntry = rt_entry_from(Node, Type, NodeId, NodeId),
              {NewEntry, NewEntry, NewEntry}
              ;
          nil -> % largest finger
              {_PredId, Pred} = gb_trees:largest(Tree),
              get_adjacent_fingers_from(Pred, Node, Type, RT)
              ;
          {value, _PredId, Pred} ->
              get_adjacent_fingers_from(Pred, Node, Type, RT)
      end
      .
  
  % Get the tuple of adjacent finger ids with Node being in the middle:
  % {Predecessor, Node, Successor}
  
negative.code:     Node = #rt_entry{type=sticky} = rt_get_node(EntryKey, RT),
      NewNode = Node#rt_entry{type=normal},
      UpdatedTree = gb_trees:enter(EntryKey, NewNode, get_rt_tree(RT)),
      RT#rt_t{nodes=UpdatedTree}.
  
  
  -spec rt_entry_from(Node::node:node_type(), Type :: entry_type(),
                      PredId :: key_t(), SuccId :: key_t()) -> rt_entry().
  rt_entry_from(Node, Type, PredId, SuccId) ->
      #rt_entry{node=Node , type=Type , adjacent_fingers={PredId, SuccId}}.
  
  % @doc Create an rt_entry and return the entry together with the Pred und Succ node, where
  % the adjacent fingers are changed for each node.
  