How can I make such that every method call to a class is routed through a wrapper

Is there a way to automatically wrap every method call to a class in a wrapper function in MATLAB? For example, suppose I have a class with methods method1 and method2 and a wrapper function wrapper_func. The wrapper_func should:

1. Print the inputs and the name of the method.
2. Call the actual method (e.g., method1).
3. Print the outputs of the method.

When I create an object obj of this class and call obj.method1, it should implicitly call wrapper_func with method1 so that the wrapper function handles the input/output printing and method execution. How can this be achieved in MATLAB?

Answer 1

[Aquatris]

Any reason why you are not using wrapper_func with an input argument that determines which method it should call? With this you can make method1 and method2 private, so noone but the class can call them and create a wraper_func public.

You might wanna switch to a switch case type of selection within the wrapper_func instead of dynamically defining the method.

classdef myClass < handle
   methods (Access = private)
      function y = method1(obj,a)
         y = 13*a;
      end
      function y = method2(obj,a)
         y = 25+a;
      end
   end
   methods (Access = public)
      function wrapper_func(obj,mtd,a)
         fprintf('\t\t Calling method %s with input %d \n ',mtd,a)
         y = obj.(mtd)(a);
         fprintf('\t\t\t Output is %d \n ',y)
      end
   end
end

[Alexander]

Thank you for a quick response.

The problem with using the wrapper_func as a way to call methods is that I have an interface which states which methods names should be used. So i need to call method1 as obj.method1 and method2 as obj.method2 instead of wrapper_func("method1", inputs) and still keep the fucntuality of the wrapper_func. I am making a wrapper that should log all functions in an already existing class which is in use. The real class have around 30 methods which needs to be logged.

[Aquatris]

Maybe you can use the listener functionality then, which would require you to add a single line of code to each of your methods. Below is an example where any method call triggers a listener function that displays which method is called in command window. I am not sure of an easy way to obtain the inputs and outputs of the method with this.

You can use custom event data (link) to store the input and outputs but that would either require making a custom notify call for each method or each method having the same input output variable names/structures.

% example usage 
a = myClass;
a.method1(5); 
a.method2(15);

% the class
classdef myClass < handle
   events
      methodCalled 
   end
   
   methods 
      % constructor that adds listener
      function obj = myClass
         addlistener(obj,'methodCalled',@(src,evnt)obj.wrapperFun(src,evnt));
      end
      function y = method1(obj,a)
         y = 13*a;
         notify(obj,'methodCalled')
      end
      function y = method2(obj,a)
         y = 25+a;
         notify(obj,'methodCalled')
      end
   end

   methods (Access = private)
      function wrapperFun(~,src,evnt,varargin)
         funCallStack = dbstack;
         methodName = funCallStack(3).name; % the method is in the 3rd place in this implementation
         disp(['Called ',methodName])
      end
   end
end

[Alexander]

Thank you for the assistance. I believe that the functionality I am after is not supported in MATLAB, sadly. However, I have to think of some other way to work around it.

[Steven Lord]

I am making a wrapper that should log all functions in an already existing class which is in use. The real class have around 30 methods which needs to be logged.

How are you hoping to make use of this log? Are you trying to determine how often functions are called in a particular piece of code for purposes of determining what to optimize? The MATLAB Profile may be able to help with this.

Alternately if you need this information in a run of some code that cannot (because it's not part of your normal workflow or because the profiling overhead is not acceptable for your workflow) run in the Profiler, the easiest approach would be to modify the methods that you want to log in the class to include a call to a helper function (which could be a local function in the class file, a private function, a function in a namespace, or a carefully named function on the MATLAB path; in that last case you shouldn't call it log) that performs the logging.

[Alexander]

Sorry for the late answer, i did not get a notice.

I am implementing a wrapper to log every function call, including inputs and outputs, to a text file. The purpose is to keep track of each function call so that if an error occurs, I can review the log to identify exactly where it went wrong.

Currently, I have the wrapper in a separate helper class. Modifying each method individually to include logging would be time-consuming because there are many methods, and future users of my logging class would also need to understand and implement these changes themselves.

My current approach involves a wrapper that logs method calls by using the syntax wrapper("methodname", inputnames, outputnames, inputs). While this provides the desired functionality, it complicates the code readability for others and alters the method call format from methodname(...) to wrapper("methodname", inputnames, outputnames, ...).

The desired functionality would be a wrapper that does not change the method call, is easy to implement in new classes and saves every function call, including inputs and outputs to a text file.

Answer 2

[SACHIN KHANDELWAL]

Hi @Alexander,

You can achieve this in MATLAB by using a combination of class inheritance and method overloading. You'll need to create a base class that defines a generic method call handler, and then use this base class in your actual class to wrap me

Let's say we have created a superclass with two methods: "method1" and "method2".

classdef mySuperClass
    methods
        function output = method1(obj, input)
            output = input * 2;
        end
        
        function output = method2(obj, input)
            output = input + 10;
        end
    end
end

We have now created another class that inherits from the superclass. This means that the new class has access to the properties and methods of the superclass.

classdef myBaseClass < mySuperClass
    
    methods
        function wrapper_fcn(obj)
            % apply your logic to handle method name etc.
            output1 = obj.method1(3)
            output2 = obj.method2(4)
        end
    end
end

I hope this is helpful.

Thanks!

[Alexander]

Thank you for you respsonse.

It feels like this solution has the same porblem as the first. I need that the call should stay the same. If i create a object from my class, test_object, i want to call the wrapped methods as test_object.method1. I dont want to have to call the wrapper function from outside the class.