anchor.diff:  
   
   -record(router,
  -    { router                        :: routerid()
  +    { id                            :: routerid()
       , rootnode                      :: nodeid()
       }).
   
   -record(route_node,
       { key                           :: nodeid()
       , router                        :: routerid()
  -    , data                          :: [data()]
  +    , data          = []            :: [data()]
       , children      = dict:new()    :: dict:dict( path_fragment(), nodeid() )
       }).
       
  +-record(registry,
  +	{ name							:: atom()
  +	, router						:: routerid()
  +	}).
  +    
   
   -record(state,
  -    { router_table                  :: ets:tid()
  +    { root_table                    :: ets:tid()
       , node_table                    :: ets:tid()
  +    , registry_table				:: ets:tid()
       , nextid        = 1             :: routerid()
  -    , registry      = dict:new()    :: dict:dict( atom(), routerid() )
  +    , nextnode      = 1             :: nodeid()
       }).
   
            
  
positive.code: 
  
  handle_call({new_router}, _From, State) ->
      {reply, ok, State};
      
      
  handle_call({new_router, Name}, _From, State) ->
      {reply, ok, State};    
      
      
  handle_call({free_router, Router}, _From, State) ->
      {reply, ok, State};
  
      
  
negative.code:     gen_server:call(?SERVER, {new_router, Name}).    
      
      
  -spec free( routername() ) -> type:ok_or_error().    
  free(Router) ->
      gen_server:call(?SERVER, {free_router, Router}).
  
      
      
  -spec add( routername(), path(), data() ) -> type:ok_or_error().
  add(Router, Path, Data) ->
      gen_server:call(?SERVER, {add_route, Router, Path, Data}).
      
  
  -spec remove( routername(), path() ) -> type:ok_or_error().    
  remove(Router, Path) ->
      gen_server:call(?SERVER, {remove_route, Router, Path}).
      
      
  
  %%%%% ------------------------------------------------------- %%%%%
      
     
  -spec get( routername(), path() ) -> [data()].
  get(Router, Path) ->
      ok.
      
      
  -spec get( routername(), path(), term() ) -> [data()].
  get(Router, Path, Args) ->
      ok.
      
      
      
  -spec get_with_matchs( routername(), path() ) -> [{data(), bound_path()}].
  get_with_matchs(Router, Path) ->
      ok.
  
  
  -spec get_with_matchs( routername(), path(), term() ) -> [{data(), bound_path()}].
  get_with_matchs(Router, Path, Args) ->
      ok.
  
  