I'm trying to define a class that is composed of several other classes but I'm having trouble getting the functionality that I'd like.
As a hopefully sufficiently generic example, assume that I have defined a transimission class and an engine class to represent, respectively, transmission and engine objects. The tranmission class definition might include:
properties
numGears
gearRatios
totalMass
end
The engine class definition might include:
properties
numCylinders
totalMass
end
In addtion, the transmission class defintion might also include a method that returns the gear ratio for a selected gear:
methods
function ratio = transRatio(transmissionObj, gearNum)
<function body>
end
end
Having defined those classes, I now seek to define a driveTrain class that includes both a transmission and an engine object:
properties
transmissionObj
engineObj
otherStuff
end
One could imagine defining a method for this driveTrain class that yields the total mass.
methods
function mass = totalMass(driveTrainObj)
mass = driveTrainObj.transmissionObj.totalMass + driveTrainObj.engineObj.totalMass;
end
end
Simple enough, right? But what if a user wants to set/get the number of cylinders in a driveTrain object? They could manually "drill down" to the engine obect which requires that they know which nested object "numCylinders" is stored in (e.g. cylinders = driveTrainObj.engineObj.numCylinders). Alternatively, we could add a numCylinders property to the driveTrain class definition and then define set/get methods that would automatically "drill down" to the correct nested object so that the nested objects are effectively invisible to the user (i.e., so that the user could simply call cylinders = driveTrainObj.numCylinders).
The second technique works fairly well since all set/get functions of this type would have an identical form (so they would be easy to define for dozens of nested properties), but what if one wants to call a method like transRatio that was originally defined within one of the nested classes? Again, the user could manually drill down to the nested object method via ratio = driveTrainObj.transmissionObj.transRatio(gearNum) but that means that the nested classes aren't invisible to the user.
I could also try defining duplicate methods within the driveTrain class for each nested method, but that's not desirable for several reasons. First, if I fully re-define the method then I've negated the whole purpose of leveraging existing classes (not to mention this makes updating the code more difficult since identical code will be in mulitple locations).
Second, if I create "wrapper" methods within the top level class that simply pass the arguments to the nested class methods then I think I need to explicitly account for the possibility of different numbers of input and output arguments for each nested method by parsing the arguments in the top level method and then explicitly calling different forms of the nested methods (again, this would make revising these methods messy because I'd have to ensure that the top level methods continue to track the nested method call syntax). As far as I know, there's not a way to simply say "if a user calls THIS top level method he really means THAT nested method".
I freely admit that I'm not familiar with all of the ways that you can work with classes. Am I going about this the wrong way? Should I be thinking about constructing these classes in a different way to accomplish what I need? Is what I'm seeking to do unrealistic?
Of course, this is just an example. In reality, the classes would have many more properties and methods as well as more complex methods.
Thanks in advance for any wisdom you might offer.
