Polymorphic copy: Difference between revisions

 

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

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}}==

 

procedure Test_Polymorphic_Copy is

Put_Line ("Cloned " & Object_3.all.Name);

Put_Line ("Cloned " & Object_4.all.Name);

The procedure Copier does not know the specific type of its argument.

Nevertheless it creates an object Duplicate of exactly same type.

=={{header|Aikido}}==

Aikido has a native <code>clone</code> function that creates a (deep or shallow) clone of any variable of any type.

class T {

public function print {

scopy.print()

 

{{out}}

before copy

class T

class S

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

REM Create parent class T:

result% = FN(mycopy.retval)(RunTimeSize%)

PRINT result%

{{out}}

<pre>

The code in "main" would also be a separate source file which would include Dog.h and Ferret.h header files (which would thems elves include the BaseObj.h header file.)

A better example of object oriented support in 'C' can be found in the source for the XtIntrinsics library of X11.

#include <stdlib.h>

#include <string.h>

ObjDestroy(o1);

return 0;

 

=={{header|C sharp|C#}}==

 

class T

Console.WriteLine(clone.Name());

}

{{out}}

 

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

 

class T

X copy = original; // copy it,

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

 

=={{header|Common Lisp}}==

With structures, <code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_cp_stu.htm copy-structure]</code> performs the right kind of copy. The object and its copy are compared under <code>eq</code>, <code>eql</code>, <code>equal</code>, and <code>equalp</code> to demonstrate that "The objective is to create an exact copy of such polymorphic object (not to create a reference, nor a pointer to)."

 

 

(defstruct (sub (:include super)) bar)

(defmethod frob ((sub sub))

(format t "~&Sub has foo = ~w, bar = ~w."

 

<pre>> (let* ((sub1 (make-sub :foo 'foo :bar 'bar))

The same technique works for <code>[http://www.lispworks.com/documentation/HyperSpec/Body/t_seq.htm sequence]</code> and its subclasses (e.g., <code>[http://www.lispworks.com/documentation/HyperSpec/Body/t_string.htm string]</code>, <code>[http://www.lispworks.com/documentation/HyperSpec/Body/t_seq.htm list]</code>) when <code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_cp_seq.htm copy-seq]</code> is used rather than <code>copy-structure</code>.

 

(format t "~&sequence has ~w elements" (length sequence)))

 

(defmethod frob ((string string))

 

<pre>> (let* ((hw1 "hello world")

 

If we assume there are no data members, this will be quite short and simple:

override string toString() { return "I'm the instance of T"; }

T duplicate() { return new T; }

writeln(orig);

writeln(copy);

{{out}}

<pre>I'm the instance of S

However this doesn't happen often in reality. If we want to copy data fields we should have something like copy constructor, that will

do the deep copy.

this(T t = null) {} // Constructor that will be used for copying.

 

orig.writeln;

copy.writeln; // Should have 'X' at the beginning.

{{out}}

<pre>I'm the instance of S p: Y23

I'm the instance of S p: X23</pre>

 

=={{header|Delphi}}==

{{trans|C#}}

 

type

begin

Main;

{{out}}

 

=={{header|E}}==

In E, a generic copy for all objects can be built out of the serialization facility, by connecting an object recognizer to an object builder without even using any intermediate serialized form:

 

 

def copy(object) {

return deSubgraphKit.recognize(object, deSubgraphKit.makeBuilder())

 

Since E does not have any static dispatch, this cannot be non-polymorphic without also being non-generic.

An example showing that it does indeed make copies follows. (For the task description, let <var>S</var> be the type of all serializable E objects, <var>T</var> be the <code>[http://wiki.erights.org/wiki/FlexList FlexList]</code> type (result of <code>diverge</code>), and the overriden method be <code> [http://wiki.erights.org/wiki/FlexList#push/1 push]</code>.

 

# value: [1].diverge()

 

 

? b

 

See also: [[Deepcopy#E]]

 

=={{header|F_Sharp|F#}}==

.NET objects have a protected method <code>MemberwiseClone</code>. This method creates a shallow copy of an object. Value type members are copied, i.e. not shared between clones. Reference type members, on the other hand, will reference the same objects after cloning.

 

// expose protected MemberwiseClone method (and downcast the result)

member x.Clone() = x.MemberwiseClone() :?> T

let s = new S()

let s2 = s.Clone() // the static type of s2 is T, but it "points" to an S

=={{header|Factor}}==

shallow copy is achieved with the "clone" word.

 

Pasting the following in a repl:

TUPLE: A ;

TUPLE: C < A ;

C new

[ clone ]

{{out}}

C

C

=={{header|Forth}}==

{{works with|4tH|3.62.1}}

{{trans|Aikido}}

There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]].

include 4pp/lib/foos.4pp

( a1 -- a2)

." after copy" cr

tcopy => print \ use "print" methods

 

 

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

 

:class T

 

obj-t print-container \ class is S

=={{header|Fortran}}==

Tested with GNU gfortran 5.2.1 and INTEL ifort 16.

!-----------------------------------------------------------------------

!Module polymorphic_copy_example_module

 

end program test

 

=={{header|Go}}==

You can see in the output that interface values of type r access t's identify method.

Values of type s would as well, except s has it's own identify method which takes precedence.

 

import (

fmt.Println("i2c:", i2c, "/", i2c.identify(), "/", reflect.TypeOf(i2c))

fmt.Println("i3c:", i3c, "/", i3c.identify(), "/", reflect.TypeOf(i3c))

{{out}}

<pre>

{{trans|Java}} (more or less)

Solution:

String property

String name() { 'T' }

class S extends T {

@Override String name() { 'S' }

 

Test:

S obj2 = new S(property: 'meh')

 

 

println "objA:: name: ${objA.name()}, property: ${objA.property}"

 

{{out}}

The deepcopy procedure is identical in both languages.

 

method a(); write("This is T's a"); end

end

}

return .cache[A]

 

Sample run:

 

Note that objects cannot be dereferenced. If you need polymorphic copy in J, you probably should not be using objects for that purpose.

 

=={{header|Java}}==

If this pattern is followed, the calls will eventually pass all the way up to <code>Object</code>'s <code>clone()</code> method, which performs a polymorphic copy.

If you do not follow this pattern, and simply use a constructor, like <code>new T()</code>, then the copy won't be polymorphic.

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

public T copy() {

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

}

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref savelog symbols binary

 

method name returns String

return S.class.getSimpleName

 

=={{header|Nim}}==

myValue: string

S1 = ref object of T

S2 = ref object of T

 

method speak(x: S1) = echo "S1 Meow ", x.myValue

method speak(x: S2) = echo "S2 Woof ", x.myValue

 

var a = S1(myValue: "Green")

a.speak

u.speak

 

u.deepCopy(a)

u.speak

a.speak

 

u.myValue = "Orange"

u.speak

a.speak

 

u = b

u.speak

b.speak

 

u.myValue = "Yellow"

u.speak

{{out}}

S1 Meow Green

S2 Woof Blue

T Hello Blue

S1 Meow Green

S1 Meow Green

S1 Meow Orange

S1 Meow Green

S2 Woof Blue

S2 Woof Blue

S2 Woof Yellow

S2 Woof Yellow</pre>

If your parent class already implements <code>NSCopying</code>, and you wish to customize the copying of your class's fields, then you should get a copy from your parent object's <code>copyWithZone:</code> method, and then perform custom initialization on the copy.

 

- (void)identify;

@end

}

return 0;

 

Analogously, there is a <code>mutableCopy</code> method to get a mutable copy of the current object (e.g. if you have an NSArray object and you want an NSMutableArray with the same contents).

=={{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|ooRexx}}==

All ooRexx objects have a copy method inherited from the object class that performs a shallow copy of the object state.

s = .s~new

s2 = s~copy -- makes a copy of the first

::method name

return "S"

 

=={{header|OxygenBasic}}==

'======

class T

 

del objA : del objB

 

=={{header|Oz}}==

We need to derive from the class <code>ObjectSupport.reflect</code> in order to have a <code>clone</code> method.

class T from ObjectSupport.reflect

meth init

{Obj setA(13)}

{Copy setA(14)}

 

Oz is not a pure object-oriented language. In fact, most values are not objects.

 

=={{header|Perl}}==

sub new {

my $cls = shift;

$x->set_data('totally different');

print "\$x is: ";

{{out}}

 

=={{header|PHP}}==

class T {

function name() { return "T"; }

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

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

 

=={{header|PicoLisp}}==

Any object can be copied by transferring the value and the property list.

If we create an object 'A':

-> $385603635

 

attr2 "def"

attr1 123

Then we can easily copy it to a new object 'B':

Inspecting 'B':

$385346595 (+Cls1 +Cls2)

attr1 123

attr3 (4 2 0)

attr4

 

=={{header|Python}}==

 

class T:

u.myValue = "Yellow"

u.speak()

{{out}}

<pre>

Under Python this would best be done with the ''pickle'' or ''cPickle'' standard modules.

 

 

source = {'a': [1, 2.0, 3, 4+6j],

'c': None}

 

 

In this example we use the ''cPickle'' module which is an implementation of the pickle features coded in C for optimal performance.

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

 

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

for key,value in source.items:

target = source[:]

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

 

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."

===Using prefab structures===

This method is useful only for prefab structures.

 

(define (copy-prefab-struct str)

[copied (copy-prefab-struct original)])

(displayln copied)

{{out}}

<pre>#s(struct:point 0 0)

 

It’s also possible to copy other structures using generics or structure-type-properties to implement a “magic”-like generic method.

 

(define (copy-struct str)

[copied (copy-struct original)])

(displayln copied)

{{out}}

<pre>#s(struct:point 0 0)

===Using classes===

There is no build-in clone method, so the class (or the interface) must implement it.

 

(define point%

(init-field color)

(define/override (clone) (new this% [x x] [y y] [color color]))

{{out}}

<pre>(#<class:point%> 0 0)

(#<class:point/color%> 0 0 black)

#f</pre>

 

=={{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"

 

=={{header|Sidef}}==

method display {

say value;

var obj1 = T("T");

var obj2 = S("S");

 

obj1.value = "foo"; # change the value of obj1

obj1.display; # prints "foo"

obj2.display; # prints "bar"

 

=={{header|Slate}}==

There is also a <tt>copy</tt> method which is universal and overridden to perform deep copies as appropriate - copying continues via recursion through slot values and should be modified on any type where equality (<tt>=</tt>) is overridden.

 

 

define: #S &parents: {Cloneable}.

 

obj1 printName.

 

=={{header|Swift}}==

required init() { } // constructor used in polymorphic initialization must be "required"

func identify() {

let another : T = original.copy()

println(original === another) // prints "false" (i.e. they are different objects)

 

=={{header|Tcl}}==

Tcl values are logically immutable, and are passed around by reference with copies being taken as and when it is necessary to do so to maintain the immutable model.

Hence an effective copy of any value is just:

With objects, slightly more work is required because they are normally passed around by name/reference.

<br>

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

method clone {{name {}}} {

# Make a bare, optionally named, copy of the object

$obj2 rename "Hocus Pocus"

$obj2 print

{{out}} (object names might vary if you run it):

<pre>

</pre>

 

{{omit from|AWK|Variables are typeless, so morphing is done on assignment}}

{{omit from|GUISS}}