Question

I have a class called ToolConfigurationVector and a class called JointVariableVector.
I need to be able to convert between those two classes (they are different representations of the same data)

A ToolConfigurationVector consists only of 6 primitive Datatypes. This is always the case.

A JointVariableVector is a representation that is specific to a Robotarm, represented by the class Arm.

So for one subclass of Arm (say SimpleArm) the representation and thus the conversion to ToolConfigurationVector is completely different to representation and conversion of another subclass of Arm (say ComplexArm)

Later, I want to use those classes like this:

Arm * someArm = new ComplexArm();
// ...
JointVariableVector jvv = someArm.currentJointVariableVector();
ToolConfigurationVector tcv = jvv.toToolConfigurationVector(); // no problem using virtual function
JointVariableVector how = tcv.toJointVariableVector(); // how?

I don’t want to include any information about which subclass of Arm is in use into ToolConfigurationVector, the information should be stored somehow in JointVariableVector

Of course, I could use templates like this:

JointVariableVector<ComplexArm> how = ...

But this is not applicable in my case, I have to solve this using ONLY

• someArm
• tcv
• ToolConfigurationVector
• JointVariableVector

I could of course give Arm a virtual method like jointVariableVectorFromToolConfigurationVector(ToolConfigurationVector v) but I cannot make it static, and because it has nothing to do with the actual Arm object implementing it as method (without static) seems wrong to me.

What can I do to get an elegant solution? Of course, this solution should be efficient, too (in terms of needed classes, objects and execution time).

Answer 1

From jvv.toToolConfigurationVector(); // no problem using virtual function it indicates that JointVariableVector holds a pointer or reference to an Arm subclass instance, or it is using something like the pImpl pattern, in order to engage in behavior virtual in the Arm subclass that it was created from.

If you want ToolConfigurationVector::toJointVariableVector to create a class which is virtual in what subclass of Arm it is specific to, either (A) ToolConfigurationVector must be virtual in which subclass of Arm the JointVariableVector will be virtual in that it produces, or (B) ToolConfigurationVector::toJointVariableVector needs to be supplied an Arm to create the JointVariableVector which will be virtual in the Arm subclass. Ie, pass an Arm to toJointVariableVector.

Alternatively, the JointVariableVector could be some kind of virgin object which later needs to be blessed with Arm context before it makes sense, but that makes a mess.

So, to be clear, JointVariableVector either has a pointer to an Arm (because its representation is a function of said Arm), or is a pImpl pattern class, based off your syntax (where instances of JointVariableVector, and not pointers to same, invoke virtual behavior). How said JointVariableVector is built is a function of the Arm it comes from. The ToolConfigurationVector loses that information. To rebuild a JointVariableVector you must then inject the Arm back into the situation.

If JointVariableVector is only a function of the type of the Arm (and not on the instance), then you can make toJointVariableVector a template function on the type of Arm it is creating a JointVariableVector for. To reduce ToolConfigurationVector dependency on Arm subclasses, have ToolConfigurationVector dispatch the call to a free template function on the type of Arm, which you can then implement adjacent to each Arm subclass and change the JointVariableVector produced.

Which would give you the syntax:

Arm * someArm = new ComplexArm();
// ...
JointVariableVector jvv = someArm.currentJointVariableVector();
ToolConfigurationVector tcv = jvv.toToolConfigurationVector();
JointVariableVector how = tcv.toJointVariableVector<ComplexArm>();