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

Question

Alexander 2024-6-28

0
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2132801-how-can-i-make-such-that-every-method-call-to-a-class-is-routed-through-a-wrapper

评论： Alexander 2024-7-9

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:

Print the inputs and the name of the method.
Call the actual method (e.g., method1).
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?

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

请先登录，再进行评论。

请先登录，再回答此问题。

Answer 1

Aquatris 2024-6-28

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2132801-how-can-i-make-such-that-every-method-call-to-a-class-is-routed-through-a-wrapper#answer_1478261

在 MATLAB Online 中打开

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

5 个评论
显示 3更早的评论隐藏 3更早的评论

Aquatris 2024-6-28

编辑：Aquatris 2024-6-28

在 MATLAB Online 中打开

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

Steven Lord 2024-7-2

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 2024-7-9

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 2024-6-28

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2132801-how-can-i-make-such-that-every-method-call-to-a-class-is-routed-through-a-wrapper#answer_1478271

在 MATLAB Online 中打开

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!

1 个评论
显示 -1更早的评论隐藏 -1更早的评论

Alexander 2024-6-28

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.

请先登录，再进行评论。

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

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

采纳的回答

5 个评论
显示 3更早的评论隐藏 3更早的评论

更多回答（1 个）

1 个评论
显示 -1更早的评论隐藏 -1更早的评论

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

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

0 个评论 显示 -2更早的评论隐藏 -2更早的评论

采纳的回答

5 个评论 显示 3更早的评论隐藏 3更早的评论

更多回答（1 个）

1 个评论 显示 -1更早的评论隐藏 -1更早的评论

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

5 个评论
显示 3更早的评论隐藏 3更早的评论

1 个评论
显示 -1更早的评论隐藏 -1更早的评论