anchor.diff:              end,
               % update failure detector:
               case ReportToFD of
  -                true -> NewPids = to_pid_list(NewRT),
  -                        OldPids = to_pid_list(OldRT),
  -                        fd:update_subscriptions(OldPids, NewPids);
  -                _ -> ok
  +                true -> update_fd(OldRT, NewRT);
  +                _Else -> ok
               end
       end
       .
  +
  +
  +%% @doc Set up a set of subscriptions from a routing table
  +-spec add_fd(RT :: rt())  -> ok.
  +add_fd(#rt_t{} = RT) ->
  +    NewPids = to_pid_list(RT),
  +    fd:subscribe(NewPids).
  +
  +%% @doc Update subscriptions
  +-spec update_fd(OldRT :: rt(), NewRT :: rt()) -> ok.
  +update_fd(#rt_t{} = OldRT, #rt_t{} = NewRT) ->
  +    OldPids = to_pid_list(OldRT),
  +    NewPids = to_pid_list(NewRT),
  +    fd:update_subscriptions(OldPids, NewPids).
  +
  +%% @doc Delete a subscription
  +%-spec delete_fd(EntryPid :: pid()) -> ok.
  +delete_fd(EntryPid) -> fd:unsubscribe(EntryPid).
  +
   %% userdevguide-end rt_frtchord:check
   
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
positive.code:                             )
                          )
                  end,
              NewRT = case Type of
                  source -> set_source_node(entry_nodeid(NewNode), RT);
                  _else  -> RT
              end,
              rt_set_nodes(NewRT, Nodes);
          _else -> RT
      end
      .
  
negative.code: %-spec add_entry(Node :: node:node_type(), Type :: entry_type(), RT :: rt()) -> rt().
  -spec add_entry(node:node_type(),'normal' | 'source' | 'sticky',rt()) -> rt().
  add_entry(Node, Type, RT) ->
      NewRT = entry_learning_and_filtering(Node, Type, RT),
      update_fd(RT, NewRT),
      NewRT
      .
  
  % @doc Add a sticky entry to the routing table
  -spec add_sticky_entry(Entry :: node:node_type(), rt()) -> rt().
  add_sticky_entry(Entry, RT) ->
     add_entry(Entry, sticky, RT)
     .
  
  % @doc Add the source entry to the routing table
  -spec add_source_entry(Entry :: node:node_type(), rt()) -> rt().
  add_source_entry(Entry, #rt_t{source=undefined} = RT) ->
      IntermediateRT = set_source_node(node:id(Entry), RT),
      % only learn; the RT must be empty, so there is no filtering needed afterwards
      NewRT = entry_learning(Entry, source, IntermediateRT),
      %% TODO is this needed? Maybe we don't need a subscription.
      add_fd(NewRT),
      NewRT
      .
  
  % @doc Add a normal entry to the routing table
  -spec add_normal_entry(Entry :: node:node_type(), rt()) -> rt().
  add_normal_entry(Entry, RT) ->
      add_entry(Entry, normal, RT)
      .
  
  % @doc Get the inner node:node_type() of a rt_entry
  -spec rt_entry_node(N :: rt_entry()) -> node:node_type().
  