anchor.diff:  
   === UriActionMapperTree
   
  -All URI fragments, which an application can handle, have to be defined with an object of class `UriActionMapperTree`. This class is then responsible for two main tasks:
  -
  -. Interpreting a concrete URI fragment visited by the user. The mapper tree tries to resolve any given URI fragment to a `UriActionCommand`. If such a command object could be found for a URI fragment, it is executed by the mapper tree.
  +All URI fragments an application can handle have to be defined with an object of class `UriActionMapperTree`. This class is then responsible for two main tasks:
  +
  +. Interpreting a concrete URI fragment visited by the user. The mapper tree tries to resolve any given URI fragment to a `UriActionCommand`. If such a command object could be determined for a URI fragment, it is executed by the mapper tree. An instance of these action commands will be created using a `UriActionCommandFactory`.
   . Assembling a valid URI fragment which can be later resolved to a particular action command by the process described above. A set of parameter values can be provided to be added to the assembled fragment so that current application state can be encoded in the URI fragment.
   
   The `UriActionMapperTree` is thread-safe. This means that only one instance of a mapper tree needs to be instantiated per application. You should try to avoid creating a mapper tree for every user session.
   
  -Creating and configuring a mapper tree can be done in two ways. You can either assemble all necessary parts by hand or you can use a builder class provided by `UriActionMapperTree`. The latter option is recommended, since the builder infrastructure leads you through the process of assembling the hierarchical structure of a mapper tree with a fluent API which at any time only allows to use those operations which make sense in the current context.
  +Creating and configuring a mapper tree can be done in two ways. You can either assemble all necessary parts by hand or you can use a builder class provided by `UriActionMapperTree`. The latter option is recommended, since the builder infrastructure leads you through the process of assembling the hierarchical structure of a mapper tree with a fluent API. This fluent API at any time allows to use only those operations which make sense in the current context.
   
   Both variants will be described in detail in the remainder of this manual.
   
  
positive.code:             .mapSubtree("user", 
                      userActionMapper -> 
                      mappers.put(userActionMapper.getMapperName(), userActionMapper)
                  ).onAction(GoToUserAreaActionCommand.class)
                  .onSubtree()
                  .map("profile").onAction(GoToUserProfileActionCommand.class).finishMapper()
                  ...
  ----
  
  With this, we can assemble a URI fragment for the `user` dispatching action mapper which will resolve to the `GoToUserAreaActionCommand` command class.
  
  === Defining Parameter Values for Generated URI Fragments
  
  
negative.code: }
  ----
  
  By providing a setter method for our routing context class annotated with `@RoutingContext`, we define the injection point for this data. After the action mapper tree has instantiated this action command class with an action command factory, it will scan the class for such a method and invoke it using the context object provided to the `interpretFragment()` method. The action command object can then use this object in its `run()` method.
  
  Note that the setter method for the routing context must be public and must have exactly one argument with the correct type of the routing context class passed to `interpretFragment()`. Otherwise, an exception is thrown.
  
  