A mapper is a mechanism that

• let's you access objects through interfaces only (by that makes your code much more general)
• manages the lifetime of those (interace implementing) objects. it therefore
• creates objects without the need to specify the concrete class of the object. you typically just want to access an interface and don't know the class.
• holds those objects until the mapper is destroyed
• shares objects that implement several interfaces and is registered for those interfaces.
• provides indirection. the interfaces to access an object can be changed.

code that uses such a mapper is more flexible since it only depends on certain interfaces to fullfill its task. when using code that uses a mapper you are very flexible in registering classes for the needed interfaces. you can register default implementations or you can register implementations that should only be picked for certain source types.

the mapper is heavily used in the different abstraction layers (model/view/viewer). each of those layers requires several interfaces and it's up to the application to do the mapping between a required interface and the class implementing this interface.
for example let's take a look at a very simple viewer, which should output the node graph of vvvv (our model) as text like this:

• rootpatch
• patch1
• node1
• pin1
• pin2
• node2
• pin3
• patch2

in order to work the viewer needs to know the name to display for each node and if a node has nodes beneath it. note that it doesn't care about the elements in its tree. it is only interested in two interfaces:

1. INamed (to get the name)
2. IEnumerable (to get a subtree for each entry)

when we create this viewer, we need to provide it with the root element (our root node) and a mapper, which knows the mapping from the required interface to the implementing class. this could be the element itself (for example a node implements IEnumerable directly), or it could be some other class (we would call it the view), which for example also enumerates the pins of a node.

how the resulting tree looks like depends entirely on the application defined mappings.