Can I Dynamically Overload A Class Method?

Hi All,

Context: I'm attempting to overload a method of class without touching the class definition or explicitly declaring a subclass.

Question: Is it possible to dynamically overload a class method either by directly overloading, dynamically creating a subclass, or intercepting method calls?

Prior Work:

The odd error message produced by the following example gives me a dim hope that its possible directly . . .

Here's an example class

classdef Hello
    methods
        function sayHi(obj)
            fprintf('Hi\n')
        end       
    end
end

I then attempt to dynamically override the sayHi function, producing an error as follows:

helloObj = Hello;
sayHola = @(obj) fprintf('Hola\n')
helloObj.sayHi = sayHola;

Assignment not supported because the result of method 'sayHi' is a temporary value.

Is there a way to make "sayHi" produce a non temporary value? Or is that saying that @helloObj.sayHi is itself a temporary value?

Answer 1

[Vimal Rathod]

A class function cannot be dynamically overloaded without creating subclass. The class protects its methods from getting modified or overloaded from outside as that changes the class definition.

In the given code,

helloObj = Hello; 
sayHola = @(obj) fprintf('Hola\n') 
helloObj.sayHi = sayHola; 

HelloObj.sayHi is a temporary value as it is just an instance of the class and was not defined in the class declaration and thus it gets its own temporary copy of all properties and cannot overload its class functions.

[Matthew]

Thank you, that's unfortunate in this case, but understandable. I can't find any reference to this being possible, but are the "prototypes" accessible anywhere for the object? I'm conceptualizing something like you can do with javascript objects.

https://coderwall.com/p/rybmma/intercepting-javascript-methods

[Guillaume]

I'm surprise that javascript lets you do that. Doesn't improve my opinion of the language.

The whole idea is completely antithetical to encapsulation in OOP, where the class is in control of its own method, so expect the fact you can't do that to be the norm rather than the exception, in languages that implement OOP.

[Matthew]

Its frowned upon for javascript too, but interceptors are actually a fairly standard way to implement AOP. Normally you would set yourself up for this though rather than trying to jury rig something after the fact.

Edit: Also you don't need to touch the prototype in javascript to create interceptors.

Answer 2

[Matt J]

You can't dynamically overload a class method, but you can get the same effect by making function handle properties that dictate the method's behavior. For example,

classdef Hello
    properties
        
        greeting=@() fprintf('Hi\n');
        
    end
    
    methods
        function sayHi(obj)
            obj.greeting();
        end       
    end
end

and now you can make dynamic changes, like

>> helloObj = Hello; helloObj.sayHi
Hi
>> helloObj.greeting = @()fprintf('Hola\n'); helloObj.sayHi
Hola

[Matt J]

Of course, you should be mindful that these kinds of things can often be accomplished with simpler kinds of properties/class designs. In your example, it seems sufficient to use a simple string property to guide the output of sayHi(), like in,

classdef Hello
    properties
        
        greeting="Hi";
        
    end
    
    methods
        function sayHi(obj)
            disp(obj.greeting);
        end       
    end
end

>> helloObj.greeting="Bonjour"; helloObj.sayHi
Bonjour

[Matthew]

This would work if modifying the class was an option, so thank you for the info.

[Matt J]

Too bad, but maybe if you elaborate on the constraints of the situation, better recommendations can be made. Why exactly can't the class be modified or subclassed? What about a container class:

classdef HelloContainer
    
    properties
        HelloObj
    end
    
    methods
        function obj = HelloContainer(HelloObj)
            obj.HelloObj=HelloObj;
        end
        
        function sayHi(obj)
          fprintf('Hola\n')
        end
    end
    
    
end

[Matthew]

Long story short, the constraints are/were non-technical, but require that:

1) The changes need to be made in the code where the object is initialized.

2) Only inline code changes can be made.