anchor.diff:  
       /products[{SingleIntegerUriParameter: id='id' default='0'}]/details -> com.example.ShowProductDetailsActionCommand
   
  -If a path segment name is assigned twice:
  +If a path segment name is assigned twice, the action mapper's name is printed in brackets:
   
       /admin -> com.example.GoToAdminAreaActionCommand
       /admin/profile[adminProfile] -> com.example.GoToAdminProfileAreaActionCommand
  
positive.code: 
  If you additionally want to see in the log which concrete action command objects are executed, you have to enable the `DEBUG` log level.
  
  == Writing a Custom Token Extraction Strategy and Query Parameter Extraction Strategy [[custom-strategies]]
negative.code: 
  === StartsWithUriPathSegmentActionMapper
  
  Class `StartsWithUriPathSegmentActionMapper` is derived from `RegexUriPathSegmentActionMapper`. An object of this mapper is also constructed with three constructor arguments. In this case, however, you don't need to supply a custom converter class. Instead, you define a prefix which a path segment needs to have in order for it to be handled by this action mapper as the second argument. The third constructor argument is again the parameter identifier for the internal string list parameter.
  
  The regular expression used by this specific regex action mapper is predefined with 
  
      <prefix>(.*)
  
  That is, the prefix you define as the second argument is matched as is, while the remainder of the matched String will be added to the String list URI parameter value. Note that if the prefix contains any characters which have a special meaning in a regular expression, they will be escaped so that the underlying regex does not get mangled by these characters.
  
  === CatchAllUriPathSegmentActionMapper
  
  This dispatching action mapper is also derived from `RegexUriPathSegmentActionMapper`. Here, the regular expression used by this mapper is predefined with `(.*)`. That is, this mapper matches the complete path segment and returns this in whole as the first list entry of its internal parameter value.
  
  To construct a new `CatchAllUriPathSegmentActionMapper`, you only have to provide the mapper name and a parameter identifier for the internal String list URI parameter.
  
  When this action mapper is used in the action mapper tree along with one or more sibling action mappers, this catch-all action mapper is always executed last to check if it is responsible for handling the current path segment. Otherwise, this action mapper would override all other sibling action mappers.
  
  == Assembling a URI Action Mapper Tree by Hand
  
  As we have learned until now, we can fully construct a URI action mapper tree by using the fluent API provided by the builder classes of class `UriActionMapperTree`. But we are not forced to do so. Another option is to assembly an action mapper tree by hand. This section explains how this can be done.
  
  When you want to construct an action mapper tree by hand, all you have to do is create instances of dispatching action mappers (for the inner sections of the tree) and simple action mappers (for the leaf nodes) and stick them together.
  
  Adding a sub-mapper to a dispatching action mapper is done with method `DispatchingUriPathSegmentActionMapper#addSubMapper()`. The following example will add two simple action mappers as sub-mapper of a dispatching action mapper.
  
  [source,java]
  ----
  SimpleUriPathSegmentActionMapper users = new SimpleUriPathSegmentActionMapper("users", "users", GoToUserAdministrationActionCommand.class);
  SimpleUriPathSegmentActionMapper groups = new SimpleUriPathSegmentActionMapper("groups", "groups", GoToGroupAdministrationActionCommand.class);
  DispatchingUriPathSegmentActionMapper admin = new DispatchingUriPathSegmentActionMapper("admin");
  
  admin.addSubMapper(users);
  admin.addSubMapper(groups);
  ----
  
  With that we build the action mappers which are able to handle the following URI fragments:
  
      #!admin/users
      #!admin/groups
  	
  Before we can actually interpret these fragments, we first need to add the dispatching mapper to an action mapper tree. We can do this by obtaining a reference to the _root action mapper_ of the mapper tree and adding the dispatching action mapper to it:
  
  [source,java]
  ----
  UriActionMapperTree mapperTree = UriActionMapperTree.create().buildMapperTree().build();
  mapperTree.getRootActionMapper().addSubMapper(admin);
  ----
  
  Since `UriActionMapperTree`'s constructor is private, we have to create a new instance of it using the builder class.
  
  === Adding parameters
  
  URI fragment parameters can be added to an action mapper with method `UriPathSegmentActionMapper#registerURIParameter()`. For example, if we want to build a mapper tree which can handle the URI fragment from section <<adding-a-parameter>>
  
      #!products/id/4711/details
  
  we can do this with the following code:
  
  [source,java]
  ----
  SimpleUriPathSegmentActionMapper details = new SimpleUriPathSegmentActionMapper("details", "details", ShowProductDetailsActionCommand.class);
  DispatchingUriPathSegmentActionMapper products = new DispatchingUriPathSegmentActionMapper("products");
  products.addSubMapper(details);
  
  SingleIntegerUriParameter idParameter = new SingleIntegerUriParameter("id");
  products.registerURIParameter(idParameter);
  
  UriActionMapperTree mapperTree = UriActionMapperTree.create().buildMapperTree().build();
  mapperTree.getRootActionMapper().addSubMapper(products);
  ----
  
  == Logging a URI Action Mapper Tree
  
  