anchor.diff:  
   `convertToValue()` takes a String as its argument and returns an object of the parameter's data type as a result. It may happen that the given argument value cannot be converted into the target data type. In this case, the conversion function is required to throw an exception of type `org.roklib.urifragmentrouting.exception.ParameterValueConversionException`.
   
  -Let's look at the implementation of `LongParameterValueConverter`'s implementation of `convertToValue()`:
  +Let's look at the implementation of `LongParameterValueConverter's` implementation of `convertToValue()`:
   
   [source,java]
   ----
  
positive.code: 
      #!admin/users/id/4711/profile/activeTabsheet/address
  
  is disassembled into the following list of tokens:
  
      ["admin", "users", "id", "4711", "profile", "activeTabsheet", "address"]
  
  This list is then interpreted by the mapper tree. Parts of this list are parameter values (here ["id", "4711"] and ["activeTabsheet", "address]). The other parts make up the directory-like hierarchical URI fragment structure (here ["admin", "users", "profile"]). For each of the directory parts (_path segments_), there is one instance of a `UriPathSegmentActionMapper` which is responsible of handling this part. These _action mappers_ have different tasks. The task of the inner segments is to pass the interpretation process on to the action mapper of the next hierarchy level. For instance, the action mapper responsible for the `admin` path segment is responsible to pass the interpretation process on to the action mapper for the `users` path segment.
  
  The second task of these action mappers is to provide a `UriActionCommand` class if there is no further sub-mapper available to which the interpretation process could be passed. In the example, the action mapper responsible for the `profile` path segment would return the action command which displays the profile view in the user administration area.
  
  There are two basic implementations available for the `UriPathSegmentActionMapper` interface:
  
  * A `DispatchingUriPathSegmentActionMapper` is an action mapper which is responsible for the inner path segments which may need to pass the interpretation process on to the next level. In the example, the action mappers for `admin` and `users` would be implemented with this class.
  * A `SimpleUriPathSegmentActionMapper` is responsible for the leaf path segments which do not have any sub-mappers. In the example, the `profile` path segment would be handled by this mapper type. The only task of `SimpleUriPathSegmentActionMapper`s is to provide a fully configured URI action command class.
  
  === UriActionCommand
  
  You can assign different parts of the URI fragment hierarchy a class which implements the `org.roklib.urifragmentrouting.UriActionCommand` interface. This interface is derived from `java.lang.Runnable` and thus implements the _Command Design Pattern_. When a URI fragment is resolved to a URI action command class, this class is instantiated and executed.
  
  Each action command needs some context before it can be executed. For example, it needs to know the URI parameter values which have been extracted from the URI fragment. This context data will be injected into the action command object by the mapper tree on demand. For this, you can add setter methods to your action command classes which are annotated with one of the following annotations: `AllCapturedParameters`, `CapturedParameter`, `CurrentUriFragment`, and `RoutingContext`.
  
  We will learn about these annotations and how to implement URI action commands later in this manual.
  
  === URI parameters and parameter value converters
  
  When you want to add parameter values to your URI fragments, you need to define a parameter object for every parameter you want to use. URI parameters are represented by classes implementing the `org.roklib.urifragmentrouting.parameter.UriParameter` interface. Parameter objects define the parameter's data type (e. g. Integer, Date, or Double) and the parameter's id. The id will be used to identify the parameter in the URI fragment. You will then only work with these type-safe parameter objects so that you don't have to hassle with String values which need to be converted into the correct data type before they can be used. The data conversion between a parameter's String representation and its typed value is taken care of by parameter value converters. Such a converter implements the interface `org.roklib.urifragmentrouting.parameter.converter.ParameterValueConverter`. The framework provides parameter and converter implementations for the standard data types. Of course you can define your own set of parameters and converters for other data types.
  
  ==== Single-Valued and Multi-Valued Parameters
  
  
negative.code: = User Manual
  Roland Krüger, mail (AT) rolandkrueger dot info
  v1.1, 2017-01-27
  :source-highlighter: coderay
  :toc:
  
  