How can I find all object of a certain handle class?

I need to find all current object memory instances of a certain handle class "MyClass".

I cannot use "findobj" because I do not have a "seed" handle.

using "whos" is also problematic because: (a) different variables can in fact point to the exact same object; (b) objects may exist without any variable poitnitng to them (for example objects that are pointed to from a "UserData" of a figure); (c) handles to soem objects may be held in persitence variables of a static method of the class.

is there a generic way to find all the objects of MyClass despites these listed difficulties?

[Walter Roberson]

There does not seem to be a way to do this. Earlier questions on the same topic have recommended that the constructor keep track of the objects. Keeping track of when to delete the objects is a nuisance in such a case.

[royk]

Thanks. Keeping track with the constructor is indeed possible, but it is hard because once I have a list pointing to the objects they will not get deleted by the garbage collector which means that I somehow need to known when to explicitly delete them ??

[Walter Roberson]

I think it might be possible to create a small bit of mex code that returns the reference count of the handle in which case you could delete when the count reaches 1 (your own link to it). But a sweep would have to be triggered somehow, and you might need a timer object for that to avoid having objects linger too long after they stop being used. You also need to be careful not to accidentally delete an object between the time you create an catalog it, and the time that a new reference to it is created when the handle is returned to the caller.

[royk]

thanks!

I am not sure I understand how to do that. Say:

h = MyClass;

hCopy = h ;

Is there somewhere a record I can access of the fact that there are now two handles to the same object? Or is there any event I can listen to that get triggered upon execution of the "hCopy=h" command ?

[Walter Roberson]

MATLAB keeps internal counts of the number of references, but does not provide any nice way to access the counts. I believe that some mex code can return the current count for a given handle.

I do not know of any mechanism to notify when a reference count changes. If it exists then it would have to fire every time you passed the handle into a function. You would also get into a number of quality of implementation questions, such as:

f(Obj) + g(Obj)

Does the reference count increase in preparation for calling f then decrease upon the return from f, then increase in preparation for calling g, then decrease after g? Or does the reference count increase once as the handle is recorded internally and the recorded handle is passed to f and then g, and then decreased again? If there were another term after that g(Obj) then would the reference count decrease upon encountering the last reference in the expression or upon the end of the expression?

[royk]

thnaks muhc

any idea/links/suggestions as to how a MEX code might be able to get the Matlab internal count of number of references to an object ?

[Walter Roberson]

mxGetReference possibly. https://www.mathworks.com/matlabcentral/answers/79046-mex-api-wish-list

Answer 1

[Guillaume]

I don't think there's any way to track down instances after the fact.

You could however track the creation and deletion of all instances of any handle class, without changing the class code, with meta.class and the events InstanceCreated and InstanceDestroyed. The whole thing is badly documented but the 2nd argument of the event is of type ClassInstance whose one of the property is the object created/destroyed.

Unfortunately, for the Destroyed case, the handle is no longer valid by the time you get it (since the object has been destroyed), so overall, I'm not sure it's that useful. Still, you could keep a reference count of object creation and destruction to know how many are in memory.

[royk]

thanks much!

It seems that can use this appraoch to create and manage a list of all object instances being created. a main problem though is that by keeping such a list of handles i will effectively be preventing the "normal" deletion of these objects, say upon clearing the workspace variable that points to them. any thoughts on how i might keep a list of all created objects in a "hidden" way such that the garbage collector will still be able to delete them (even though they are pointed to from this central list)?

[Guillaume]

Yes, as I said, in practice it's not going to work well for tracking which objects are still existing, particularly as you get notification of an object destruction but don't know which one. It's probably only good if you want to just track the number of objects that exist.

By necessity any method that tracks creation and deletion of the objects must keep a handle to the objects, if you then want to be able to list them at any time. As matlab doesn't provide anything similar to weak pointers in C++, your list would prevent object destruction indeed.

You should explain why you want to do this, though. That's a very odd thing to want to do.

[royk]

Thnaks

as for the goal: I would like to be able to give all the object centralized created command (like to save their data to files).

[Walter Roberson]

Possibly in that situation it would work to instead have each object save its state to a file whenever the state changes, and have the destructor delete the file. The central command would then consist of taking a copy of all of the state files.

[royk]

that's what i ahve now. it is a bit messy and inherently slow.

I am thinking anohter possibility is to have all objects listen to a "SaveFiles" event from the central object

[Guillaume]

Yes, this is something that is cleanly implemented with events and listener.

You could have the command carried out by each object individually (they receive the command when the event is triggered) or report back to the controller which carry the command on each. I'm allowing both methods here.

First, the event arguments:

classdef (ConstructOnLoad) HasCommandEventArgs < event.EventData 
    properties (SetAccess = private)
        Command;        %The actual command to carry out. Handle to a function with one input: the class instance that the command applies to     
        CommandArgs;    %Arguments to send to the controller when reporting back.
    end
    methods 
        function this = HasCommandEventArgs(command, args)
            this.Command = command;
            this.CommandArgs = args;
        end
    end
end

Then, the controller:

classdef MasterController < handle
    events
        HasCommand;
    end
    methods (Access = ?MyClass)  
        function this = MasterController()
        end
        
        %Function called by each instance once the event has been raised. 
        %Each instance reports back and the master controller can do whatever it wants sinc it gets the instance and the command arguments
        function CheckIn(this, instance, commandargs)
            fprintf('\nInstance %s reported back with command args: %s\n\n', instance.Name, commandargs);
        end
    end
    methods (Access = public)
        function SendCommand(this)
            %basic command here, just ask the instances to disp themselves, and command arg is just a UUID
            %you could tell the objects to save themselves, or pass a filename as argument and they'll report back with that filename for the controller to save them
            uid = java.util.UUID.randomUUID;
            notify(this, 'HasCommand', HasCommandEventArgs(@disp, uid));
        end
    end
end

And finally, the class to track:

classdef MyClass < handle
    properties (SetAccess = private)
        Name;
    end
    
    properties (Access = private)
        controllerlistener;
    end
    
    methods (Static)
        %Singleton controller for the whole class.
        function controller = getController()
            persistent mc;
            if isempty(mc)
                mc = MasterController;
            end
            controller = mc;
        end
    end
    
    methods
        %When the object is created, it listens for the controller HasCommand event
        %Note that when the instance is destroyed, so is the listener 
        function this = MyClass(name)
            this.Name = name;
            controller = this.getController();
            this.controllerlistener = event.listener(controller, 'HasCommand', @this.DoCommand);
        end
    end
       
    methods (Access = private)
        function DoCommand(this, source, eventargs)
            command = eventargs.Command;
            command(this);
            source.CheckIn(this, eventargs.CommandArgs);
        end
    end
end

And simple usage example:

>> mc = MyClass.getController;
>> a = MyClass('A');
>> b = MyClass('B');
>> mc.SendCommand
  MyClass with properties:

    Name: 'B'

Instance B reported back with command args: 4284ae7d-d68a-4fdd-8294-4a8b63a11a12

  MyClass with properties:

    Name: 'A'

Instance A reported back with command args: 4284ae7d-d68a-4fdd-8294-4a8b63a11a12

[royk]

Very nice implementation!

probem solved. much thanks

one suggestion: the handle of MyClass to the controller can be a Constant property of MyClass. this makes it all more elegant avoiding the need for the getController function and the persistence variable