Polymorphic copy: Difference between revisions

It is trivial to copy an object if its type is known:

int x;

int y = x;

Here x is not polymorphic, so y is declared of same type (''int'') as x. But if the specific type of x were unknown, then y could not be declared of any specific type.

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

Copier (Object_2);

end Test_Polymorphic_Copy;

The procedure Copier does not know the specific type of its argument. Nevertheless it creates an object Duplicate of exactly same type. Sample output:

<pre>

=={{header|C++}}==

#include <iostream>

copy.identify_member(); // and check what type of member it contains

}

=={{header|Java}}==

Here we implement a "copy" method once in the base class because there is by default no public way to copy an object from outside the class in Java. (There is a protected, not public, "clone" method inherited from Object.)

public String name() { return "T"; }

public T copy() {

System.out.println(copier(obj2).name()); // prints "S"

}

=={{header|OCaml}}==

I decided not to use classes and inheritance here because structural subtyping is more natural in OCaml. Oo.copy is polymorphic over all object types.

object

method name = "T"

let () =

print_endline (Oo.copy obj1)#name; (* prints "T" *)

=={{header|PHP}}==

class T {

function name() { return "T"; }

echo $obj3->name(), "\n"; // prints "T"

echo $obj4->name(), "\n"; // prints "S"

=={{header|Python}}==

class T:

u.myValue = "Yellow"

u.speak()

creating initial objects of types S1, S2, and T

S1 Meow Green

In many cases the most portable and robust "copy" would be made by serializing the source object and then de-serializing it back into the target. Under Python this would best be done with the ''pickle'' or ''cPickle''

import cPickle as pickle

target = pickle.loads(pickle.dumps(source))

In this example we use the ''cPickle'' module which is an implementation of the pickle features coded in C for optimal performance. We import it as ''pickle'' since we intend to use only those features which are common to both implementations. (The pure Python implementation is retained for those who which to create their own classes derived therefrom). The ''dumps()'' and ''loads()'' methods dump the data structures to a string and load them from a string, respectively. (The more common use of ''pickle'' is to serialize the data out to a file or over a network connection using file-like ''.read()'' and ''.write()'' methods. For those we'd use the ''pickle.dump()'' and ''pickle.load()'' methods).

For the simplest cases one can use simple Python introspection to copy simple objects:

target = source.__class__() # Create an object of the same type

if hasattr(source, 'items') and callable(source.items):

else: # Following is not recommended. (see below).

target = source

This example handles dictionaries (and anything that implements a sufficiently dictionary like interface to support the ''items()'' method along with the ''__setitem__()'' method. (statements of the form '''''x[y] = z''''' in Python are implicitly calling the ''__setitem__()'' method of the "x" object, passing it a key of "y" and a value of "z." Similarly this code tests if an item is a sequence (one can call the "len()" built-in function on it) and, if so, uses a slice assignment to perform a shallow copy. For any other type of object a simple binding is performed. Technically this last case will not "copy" anything ... it will create a new name binding to the object to which "source" was already a reference. The earlier binding of a "blank" instance of the source's __class__ will be replaced. So the trick of creating the blank object of the same type is only meaningful for the other types. In the cases of strings, integers and other numbers the objects themselves are immutable and the bindings are all dynamic (so the entire task is moot with respect to them).

=={{header|Ruby}}==

All Ruby objects inherit two methods for copying themselves: "clone" and "dup". I don't really understand the difference between them.

def name

"T"

obj2 = S.new

puts obj1.dup.name # prints "T"