One of challenges with the old mapper was what to do when setting new values of min & max.
In the above diagram we see a range established by a min & max. 

e.g.  mapper = new Mapper(-1, 1, -1, 1)  

min & max input will be -1 & 1  .. min & max output will be -1 & 1

In the diagram, if the new min value is @ position "value 1 or 2 " ... the result is well understood, but what if the new value is at position 3 ?

example of this is 

mapper.setMin(2)  .. what should happen ?

Should the min max switch ? Should nothing happen ie the value not be set ?

Mapping out the Mappers !  - I worked for probably too long on mapping all these details out, but in the end, when you require yourself to map it all out solutions begin to appear.

The Work-E robot kills furniture when the sabertooth motor controller operates higher than power value "20".
The Sabertooth's power range is -127 (full throttle backwards) to 127 (full throttle forwards).

The following is a list of diagrams "trying" to get "What I Want" - which is a mapping between the joystick and sabertooth which has maximal amount of control within a safe operating range.

It took some digging to see where this rabbit hole of data goes ..  
fig.1 Is a diagram of how things would work without explicitly setting a mapper.  There is a default mapper in the Sabertooth motor controller which maps -1.0 <=> 1.0 values to what the Sabertooth hardware requires -127 <=> 127.  However, only a small range of motion of the Joystick doesn't fall in the valid, yet dangerous range of the Sabertooth.  A Min Max is set, but doesn't affect the system at all, because I mistaken set it for Sabertooth values, not input values like setMinMax(-0.16, 0.16).  Even if it was set properly, the mapping is not what I want, because I can't use the full range of the Joystick.

fig.2 Without thinking much, I decide to try to get the joystick mapper to map ranges.  Of course this fails, because the joystick is "input" and its mapped values are correct output ranges, but they are used as "input" to the Sabertooth. In this mode any movement of the Joystick  breaks furniture :P

fig. 3  The Joystick mapping was a mistake on my part, but a motor mapping "should have" worked.  It didn't :(
Potentially, different motors on the same motor controller might need different mappings. It produced the correct "output" values, but as INPUT to the Sabertooth, and the Sabertooth has its own global mapping G(x) which came with the service.  This global mapping is an attempt to provide a default worky mapping since the sabertooth requires the -127 to 127 range.  Sadly, the incoming data goes through both mappings F(G(x)) and produces dangerous output from any Joystick movement :( ... Now any Joysticks data makes WORK-E slam into the wall.

This is the solution I'm thinking of trying to implement. The MotorControl never "calculates", but only supplies an alternate config (as a mapper) for the MotorController. So the controller simply checks to see if the MotorControl has a mapper, and if it does, the MotorController uses it.  If the MotorControl does not have a mapper as config, the MotorController will uses its own global mapper.

This supports the following :

• The Sabertooth will still have its default global mapper, which will support default use .. goodtimes ..
• The Sabertooth could supply its default global mapper as config to any unset MotorControl mapper - allowing it later to be customized on an individual basis.
• Individual MotorControls can supply their "specialized" mapping, and the Sabertooth will use it instead of its global one.

I think this works well, except I see at least one problem.  The setting of MinMax is done with mappings

leftMotor.setMinMax(-20, 20)

This would mean a mapper in MotorControl would be "set" - its default mapping is (-1, 1, -1, 1).
If this was done before attaching to the Sabertooth, the mapping would remain (-1, 1, -1, 1) and the end result would be not moving the motor because the final output would be too small, joystick values could end up on the serial line to the hardware.

This is to open the discussion of where we map values.

The use case is to operate a Motor using a Joystick.

This is the current flow :

Joystick == axis value ==> MotorControl.move( input ) ==> MotorController.moveMotor(input) ==> Hardware

My question is simple ... should MotorControl provide a mapper to be used for the final value which the MotorController sends to the hardware ?

I see comments in the code saying "not to do this".
However, "if" a power mapping is to be provided - a unique mapper will potentially be needed inside the MotorController for each MotorControl attached to the MotorController  - this means the MotorController will need to identify each MotorControl and apply its specific mapper.  To me, at this moment, it seems this would be simplified if each MotorControl motor stored its own mapper.  But, that would go against the comments in the code ... can someone remind me "why" we don't want to do it this way ?