There is a sneaky Matlab way to do this that exploits functions within fuctions and the fact that the internal function will have access to the scope of the external one. The member function would be as follows:
function funcPtr = entryPoint(this)
funcPtr = @redirectFunction;
function redirectFunction()
this.actualfunctionToCall();
end
end
then in the Matlab code, you could do as follows:
myFunc = classObj.entryPoint();
which would give you the function pointer to the internal function. Execution
would redirect to the actual member function. It is possible to include arguments in the redirect function and they'd be accessible to you in the internal function. You could also pass in extra arguments to the entryPoint function and those arguments would be accessible to the internal function (presuming that inernal function were defined to accept arguments, varagin is possible too).
Mind you, this will be permanently tied to the actual instance classObj. If you wanted the function pointers to many instances, then you'd have to invoke the entryPoint for each instance, then maintain the function handles in separate variables or in an array or list, to iterate through them or do other stuff.
In your case, the call would be
N.txStep = N.txClass.entryPoint();
...
N.txStep();
It would be easy to then overwrite the txStep field of N to point to whichever you wanted.
I haven't figured out a better way and use this approach all the time. I even have static member functions for a class do this to have run-time dynamically instantiated class objects based on the arguments and externally available (in the outer function scope) variables. It's a cheap way to have a dynamic factory interface.
If I don't think of a way to do otherwise, or Matlab doesn't provide a solution like can be done in python, this is how I am going to implement a ROS message callback within Matlab that is object specific.
