Thread Subject: Deep copy of cell array with handle-object members

I have a cell array that may at times contain an object of a
user-defined handle-based class. I'd like to make a deep
copy of the entire cell array, including deep copies of the
cell array's user-defined class objects.

I am using the following code to generate a deep copy of a
class that may contain subclasses, but it does not work with
cell arrays:

function new = copy(this)
new = feval(class(this));
p = fieldnames(this);
for i = 1:length(p)
    if isobject(this.(p{i}))
       new.(p{i}) = copy(this.(p{i}));
    elseif isa(new.(p{i}),'cell')
       new.(p{i}) = mxDuplicateArray(this.(p{i}));
    else
       new.(p{i}) = this.(p{i});
    end
end
end

Any help? Thanks.

In article <g4tip2$i4b$1@fred.mathworks.com>,
anothermathgeek+matlab@gmail.com says...
> I have a cell array that may at times contain an object of a
> user-defined handle-based class. I'd like to make a deep
> copy of the entire cell array, including deep copies of the
> cell array's user-defined class objects.
>
> I am using the following code to generate a deep copy of a
> class that may contain subclasses, but it does not work with
> cell arrays:
>
> function new = copy(this)
> new = feval(class(this));
> p = fieldnames(this);
> for i = 1:length(p)
> if isobject(this.(p{i}))
> new.(p{i}) = copy(this.(p{i}));
> elseif isa(new.(p{i}),'cell')
> new.(p{i}) = mxDuplicateArray(this.(p{i}));
> else
> new.(p{i}) = this.(p{i});
> end
> end
> end
>
> Any help? Thanks.
>

Why do you need the deep copy? What is happening that MATLAB isn't
doing the right thing automatically for you?


--
Loren
http://blogs.mathworks.com/loren/

I need it to spawn a new object that is exactly the same,
but be able to edit each independently. For example, if my
class stored the information for a person, (let's say I have
a 'person' class), I may want to copy the person and only
edit their name and age if they live in the same household.
This would be easier than creating a new person from
scratch, and re-entering all of the parameters.

As I have it now, if the class contains a cell array, which
itself contains a user-defined object, a deep copy of the
user-defined object is not made, and the two 'people' share
a handle to the same object (if the object is in a cell
array). I can make a deep copy of an object using the code
above, but I have no way of controlling the '=' operator
used to copy cell arrays so that deep copies are made.

In article <g4vtun$qv9$1@fred.mathworks.com>,
Daniel <anothermathgeek+matlab@gmail.com> wrote:
>I need it to spawn a new object that is exactly the same,
>but be able to edit each independently. For example, if my
>class stored the information for a person, (let's say I have
>a 'person' class), I may want to copy the person and only
>edit their name and age if they live in the same household.
>This would be easier than creating a new person from
>scratch, and re-entering all of the parameters.

That doesn't sound like a need for a deep copy; that sounds like
a need for a shallow copy followed by changing the parameters that
need to be changed.

A shallow copy would be suitable for cases where attributes
near the leaf of the object need to be changed. A deep copy would
be suitable for the case where you want to create an entire new
parallel country with parallel states/provinces and parallel cities
and so on.

Quick test for you: if the city were to be officially renamed,
such as from "Bombay" to "Mumbai", then do you only want to have
to touch the one city object that all the individuals are inheriting
from, or do you want to have to search each object individually and verify
that the appropriate attributes (city name, state/province name,
country name) have identifiers that test equal to the old identifiers,
and change the appropriate attribute to the new ones?

--
Current spam load: 750-800 messages per day (March 4, 2008)

Hi Daniel,

One way to get what you want might be to recursively call your copy function
on elements of cell and struct arrays. There is no way to get MATLAB to do
this when copying cells because the MATLAB copy for a handle object copies
the handle rather than creating a new object. This is how I think I would
implement this:

function new = copy(this)
  new = feval(class(this));
  p = fieldnames(this);
  for i = 1:length(p)
    if isobject(this.(p{i}))
      new.(p{i}) = copy(this.(p{i}));
    elseif isa(new.(p{i}),'cell')
      new.(p{i}) = copycell(this.(p{i}));
    elseif isa(new.(p{i}),'struct')
      new.(p{i}) = copystruct(this.(p{i}));
    else
      new.(p{i}) = this.(p{i});
    end
  end
end
function CC = copycell(C)
  n = prod(size(C));
  C = cell(size(C));
  for k = 1:n
  CC{k} = copy(C{k}); % copy each cell
  end
end
function SC = copystruct(S)
  C = copycell(struct2cell(S));
  SC = cell2struct(C, fieldnames(S));
end

"Daniel " <anothermathgeek+matlab@gmail.com> wrote in message
news:g4tip2$i4b$1@fred.mathworks.com...
>I have a cell array that may at times contain an object of a
> user-defined handle-based class. I'd like to make a deep
> copy of the entire cell array, including deep copies of the
> cell array's user-defined class objects.

Why do you need a deep copy? From my understanding, MATLAB
is smart enough to take care automatically of duplicating
subfields/sub-elements.

Example:

c={1 {2 3} 4}
cc = c % "Shalow" copy

cc{2}{2} % 3
c{2}{2} % 3

cc{2}{2}=5 % Change a sub field

cc{2}{2} % 5
c{2}{2} % 3

cc{2}{1} % 2

Can you give a case where "deep copy" is needed?

Bruno