anchor.diff:  
   When this fragment is interpreted by the mapper tree, the original parameter value `some/value/100%` will be added to the `CapturedParameterValues` object.
   
  -== Configuring the URI Action Mapper Tree
  +== Configuring the URI Action Mapper Tree [[configuring-mapper-tree]]
   
   In this section, we will learn how a URI action mapper tree can be further configured. As we have seen in the beginning of this document, a URI action mapper tree can be constructed with a set of builders. Constructing a new action mapper tree is initiated with the static function `create()`:
   
  
positive.code: * set a custom URI token extraction strategy, and
  * set a custom query parameter extraction strategy.
  
  We have already learnt, how a default action command is used and which parameter modes are available. The latter two options, URI token extraction strategy and query parameter extraction strategy, are new for us. We will learn about them in section <<custom-strategies>>.
  
  If we want to set all these values, we can do this using the builder's fluent API:
  
  
negative.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]]
  
  When the URI action mapper tree interprets a URI fragment, any given fragment is first broken into a list of tokens. For example, the URI fragment
  
      #!products/id/4711/details
  
  will be transformed into the list
  
      ["products", "id", "4711", "details"]
  
  This list is then interpreted sequentially from start to end. As you can see, the `/` character is interpreted as the separator of the tokens and the URI fragment is split along this character.
  
  This behavior can be changed. The concrete algorithm that breaks a URI fragment into a token list is implemented in a _strategy class_. You can provide your own implementation of this strategy by implementing interface `org.roklib.urifragmentrouting.strategy.UriTokenExtractionStrategy`. To do so, you need to implement two methods.
  
  * `List<String> extractUriTokens(String uriFragment)` receives a URI fragment and transforms it into a list of tokens
  * `String assembleUriFragmentFromTokens(List<String> tokens)` does the opposite and assembles a String from a list of tokens which can be transformed back into the initial list with the first method.
  
  The default implementation of this interface is `org.roklib.urifragmentrouting.strategy.DirectoryStyleUriTokenExtractionStrategyImpl`.
  
  There is another strategy interface you can provide. When you use parameter mode `ParameterMode#QUERY` for your action mapper tree, the URI fragment parameters are appended to the URI fragment like URL query parameters:
  
      #!admin/users/showHistory?id=4711&startDate=2017-01-01&endDate=2017-01-31
  
  You can implement interface `org.roklib.urifragmentrouting.strategy.QueryParameterExtractionStrategy` to define your own set of rules how these types of parameters should be extracted from the URI fragment and transformed into a `Map<String, String>`. To do so, you need to implement three methods.
  
  * `Map<String, String> extractQueryParameters(String uriFragment)` extracts all URI parameters contained in the given URI fragment in query mode and passes them back as a parameter map.
  * `String stripQueryParametersFromUriFragment(String uriFragment)` removes the section from the given URI fragment which contains the query parameters.
  * `String assembleQueryParameterSectionForUriFragment(Map<String, String> forParameters)` receives a map of URI parameter values and returns the query String for these parameters to be appended to the URI fragment. 
  
  The default implementation of this interface is `org.roklib.urifragmentrouting.strategy.StandardQueryNotationQueryParameterExtractionStrategyImpl`.
  
  Refer to section <<configuring-mapper-tree>> to see how you can set your custom strategy implementations on an action mapper tree.