Deep copy of handle object?

Does MATLAB seriously fail to provide a deep copy for a handle object (i.e. java's clone())?

Thanks in advance!

[D G]

I ended up saving a copy of the object to a mat file in the temporary directory, reloading, and then deleting the file. Works perfect.

[Thaddeus]

I have a project that is still [shamefully] using this save-to-file-then-reload workaround. Is there really still not a better way to do this??

...I'm seeing 178 views of this in last 30 days, so its clearly still something people are curious about. I've followed all the matlab.mixin.copyable rabbit holes, but as far as I can tell that method only applies to highly-structured/textbook OOP cases where the set of fields to be deep copied are preordained (which would be ideal, but not always the case in the real world).

Essentially, to do a recursive deep copy on a struct that contains a mixed hierarchy of object & non-object subfields.

[Walter Roberson]

I don't think it can work until you can solve the issues discussed in https://www.artima.com/intv/issues.html#part3

[Ben Barnett]

If you are using the save-to-file-then-reload workaround. You might want to try using the undocumented Matlab functions described here.

copyStream = getByteStreamFromArray(objToCopy);
objCopy = getArrayFromByteStream(copyStream);

This should remove the file IO access from the process.

Answer 1

[Mark Mikofski]

This topic is covered in this MATLAB newsgroup post clone (deep copy) a handle object. Note comp.soft-sys.matlab (CSSM) is now mirrored on Google Groups.

It looks like this has been implemented in MATLAB at least as early as R2012a (and possibly earlier).

Subclass your object to matlab.mixin.Copyable [1] instead of handle and that will expose the copy method [2] which will perform shallow copies (no dependent or nested objects or recursive properties).

The methods can be overloaded and an example is given for a method to make deep copies.

References:

[1] Superclasses providing copy functionality for handle objects

[2] Copy array of handle objects

Answer 2

[Walter Roberson]

Hmmm, so I have a handle class which allocates resources out of an internal pool, and creates objects that have a reference ID and uses the resource. Okay, now deep copy it.

The ID gets copied, the resource pointer gets... ? Copied? Or does there hypothetically exist a clone() virtual method for each superclass that would get invoked so the class could allocate another resource object, updating the reference ID? If it is a plain copy then when one of the two objects is deleted, the class is going to deallocate the resource associated with the reference ID and then you have problems when you go to use or delete the second copy. If it is not a plain copy, then can you guarantee there are additional resources available to allocate, and the operation is meaningful?

For example suppose I have a handle class that references a serial port object out of a modem pool. If you copy the same serial port then you get conflicts with resource use between the two objects. If you allocate a new modem out of the pool of modems, what if no modems were available, and is allocating a second modem what you really want to have happen in this situation?

If you deep-copy a handle that references a memory-mapped file, then should the file be duplicated?

I'm not convinced that providing an automatic deep copy method is a good idea in a language in which resources can be represented as well as pure data.

[D G]

This is not true. A deep copy implies that all resources are duplicated. As the name says, it is a DEEP copy. All sub-resources would be duplicated as well. Take a look at what Java's, clone() method does.

This is such a basic OOP function that I am surprised MATLAB has overlooked it. As far as cloning serial port objects, there has to be a level of intelligence. You can't build a language for complete idiots.

[Walter Roberson]

What part of what I wrote was "not true" ?

Serial ports. File references. Reserved memory. Graphics card buffers (e.g., for playing video). Parallel ports. Distributed objects. GPUs or anything that references memory stored on a GPU. Network devices. Anything that contains an opaque pointer, including a reference to a Java object, and including anything that uses a Mex routine that allocates memory itself.

Serial ports are used for many types of USB devices, and are used for accessing many kinds of instruments, and used in many kinds of control systems. They are a fundamental interface model.

[Malcolm Lidierth]

Take a look at Bloch's Effective Java book to see what problems Java's clone presents.

[Walter Roberson]

One page I found on that: http://www.artima.com/intv/issues3.html

[D G]

Still would be useful to have for 90% of classes instead of worrying about the 10% of the time it could cause problems. At some point the programmer has to be responsible for how he uses his tools.

[Bill Tubbs]

This discussion seems quite old so not sure if it is still relevant. Found this documentation page:

Implement Copy for Handle Classes

Is this what we should be using now?

Answer 3

[per isakson]

It's an issue, which has been discussed in the newsgroup

% Subject: clone (deep copy) a handle object
% From: Peter O'Connor
% Date: 15 Dec, 2011 23:35:11
% Message: 11 of 12

and in the FEX

%   See FEX contribution with comments:
%   Clone Handle Object - using MATLAB OOP
%   by Bobby Nedelkovski (The MathWorks)
%   12 Feb 2009 (Updated 28 Sep 2009)

.

I ended up using save( ...., '-v6' ) and load.

[Nikolaus Koopmann]

why with '-v6'?

[Walter Roberson]

-v6 stored objects a different way, enough so that the objects would end up rebuilt.

However, MATLAB has added new object facilities since the 2012 timeframe, and storing objects into -v6 is now not always viable.

Answer 4

[James Tursa]

You could try a mex function, but I have not investigated how the API routine mxDuplicateArray behaves with handle-derived class variables:

#include "mex.h"
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
    if( nlhs > 1 ) {
        mexErrMsgTxt("Too many outputs.");
    }
    if( nrhs != 1 ) {
        mexErrMsgTxt("Need exactly one input.");
    }
    plhs[0] = mxDuplicateArray(prhs[0]);
}

Place the above code in a file on the MATLAB path, e.g. deepcopy.c, make that directory your current directory, and then compile as follows:

mex deepcopy.c

If prompted, pick any C/C++ compiler that shows up in the list (e.g., the LCC compiler).

[James Tursa]

Checked ... and this doesn't make a deep copy.