Copying objects - Revision history

Dme: /* Usage Notes */

2017-01-24T22:51:00Z

Usage Notes

← Older revision		Revision as of 22:51, 24 January 2017
Line 38:		Line 38:
	<li>Not all objects that it is possible to copy should be allowed to be copied. As a general rule of thumb, any object that holds information external to its own public or private variables is a good candidate for not being allowed to be shallow or deep copyable. For example, consider a class that is used to manage a record. Object private variables might be dependent on the contents of the record, but if you have multiple instances of the object and the class updates the record, the private variables in one instance could end up out of synch with the record due to updates by another source.		<li>Not all objects that it is possible to copy should be allowed to be copied. As a general rule of thumb, any object that holds information external to its own public or private variables is a good candidate for not being allowed to be shallow or deep copyable. For example, consider a class that is used to manage a record. Object private variables might be dependent on the contents of the record, but if you have multiple instances of the object and the class updates the record, the private variables in one instance could end up out of synch with the record due to updates by another source.

	<li>For an object to be shallow or deep copyable, all ~~it's~~ contained objects must themselves be shallow or deep copyable, respectively. The compiler ensures that if an object's class contains an object member (or an object member contained in that object member's "descendant objects,") whose class definition does not specify <code>Allow Copy</code> or <code>Allow DeepCopy</code>, the original object is not shallow or deep copyable, respectively.<br />The <var class="product">SOUL</var> system classes that are shallow or deep copyable are specified in the following section.		<li>For an object to be shallow or deep copyable, all its contained objects must themselves be shallow or deep copyable, respectively. The compiler ensures that if an object's class contains an object member (or an object member contained in that object member's "descendant objects,") whose class definition does not specify <code>Allow Copy</code> or <code>Allow DeepCopy</code>, the original object is not shallow or deep copyable, respectively.<br />The <var class="product">SOUL</var> system classes that are shallow or deep copyable are specified in the following section.

	<li>Allow <var>DeepCopy</var> does not imply <var>Allow Copy</var>. However, [[#Inheritance and polymorphism\|inheritance]] permits an <var>Allow Copy</var> designated class to have its own <var>Copy</var> method defined, and it permits an <var>Allow DeepCopy</var> designated class to have its own <var>DeepCopy</var> method.		<li>Allow <var>DeepCopy</var> does not imply <var>Allow Copy</var>. However, [[#Inheritance and polymorphism\|inheritance]] permits an <var>Allow Copy</var> designated class to have its own <var>Copy</var> method defined, and it permits an <var>Allow DeepCopy</var> designated class to have its own <var>DeepCopy</var> method.
Line 46:		Line 46:
	<li>If a user-defined class already has a method called <code>Copy</code> (or <code>DeepCopy</code>), it does not conflict with the <var>Object</var> class <var>Copy</var> (or <var>DeepCopy</var>) method. However, due to inheritance, the user class <code>Copy</code> definition must specify that it is an override.		<li>If a user-defined class already has a method called <code>Copy</code> (or <code>DeepCopy</code>), it does not conflict with the <var>Object</var> class <var>Copy</var> (or <var>DeepCopy</var>) method. However, due to inheritance, the user class <code>Copy</code> definition must specify that it is an override.
	</ul>		</ul>

	===Example===		===Example===
	The following fragment sketches a deep copyable user class that contains two objects. The contained objects contain no further object references, but they are both subject to update from an external source. The class designer wants instances of the class to be deep copyable only, so class object copies are insulated from external changes to its constituent objects. A shallow copy of a class object, with pointers to its contained objects, would be modified upon changes to its contained objects.		The following fragment sketches a deep copyable user class that contains two objects. The contained objects contain no further object references, but they are both subject to update from an external source. The class designer wants instances of the class to be deep copyable only, so class object copies are insulated from external changes to its constituent objects. A shallow copy of a class object, with pointers to its contained objects, would be modified upon changes to its contained objects.

JAL: misc formatting

2017-01-23T22:56:09Z

misc formatting

← Older revision		Revision as of 22:56, 23 January 2017
Line 6:		Line 6:
	and if a contained object itself contains objects, deep copy copies those references and objects, and if any of those objects have contained objects, deep copying continues like this until the chain of objects contained in contained objects is exhausted.		and if a contained object itself contains objects, deep copy copies those references and objects, and if any of those objects have contained objects, deep copying continues like this until the chain of objects contained in contained objects is exhausted.

	For example, if a simple object (%S) contains multiple variable members, one of which is an object variable(%c, which references an object that has no contained object variables),		For example, if a simple object (<code>%S</code>) contains multiple variable members, one of which is an object variable(<code>%c</code>, which references an object that has no contained object variables),
	a shallow copy produces a matching object with matching variable members, including %c.		a shallow copy produces a matching object with matching variable members, including <code>%c</code>.
	Remembering that %c is a reference and not the actual object, the shallow copy of an object that contains an object pointer thus produces a matching object and object pointer.		Remembering that <code>%c</code> is a reference and not the actual object, the shallow copy of an object that contains an object pointer thus produces a matching object and object pointer.
	A deep copy of %S produces two objects: one object that matches %S with a pointer to %c, and one object that is a replica of the actual object that %c references.		A deep copy of <code>%S</code> produces two objects: one object that matches <code>%S</code> with a pointer to <code>%c</code>, and one object that is a replica of the actual object that <code>%c</code> references.

	For simple objects (objects without contained objects), a shallow copy is the same as a deep copy.		For simple objects (objects without contained objects), a shallow copy is the same as a deep copy.

	'''Shallow copies''' may be most useful with collections, say for sorting an <var>Arraylist</var>. To preserve the original order of a given <var>Arraylist</var>, you make a shallow copy of the collection to avoid the expense of making copies of any <var>Arraylist</var> objects, then you sort the shallow copy on whatever criterion you want. A shallow copy method may also in turn be used as a building block for constructing copy methods of arbitrary complexity for hierarchical object structures.		'''Shallow copies''' may be most useful with collections, say for sorting an <var>Arraylist</var>. To preserve the original order of a given <var>Arraylist</var>, you make a shallow copy of the collection to avoid the expense of making copies of any <var>Arraylist</var> objects; then you sort the shallow copy on whatever criterion you want. A shallow copy method may also in turn be used as a building block for constructing copy methods of arbitrary complexity for hierarchical object structures.

	'''Deep copies''' provide a facility for copying an entire arbitrarily complex object forest, and they are probably more widely useful than shallow copies. For example, deep copying is essential internally in <var class="product">SOUL</var> system methods that let you pass an object between two threads and reference the object on both threads.		'''Deep copies''' provide a facility for copying an entire arbitrarily complex object forest, and they are probably more widely useful than shallow copies. For example, deep copying is essential internally in <var class="product">SOUL</var> system methods that let you pass an object between two threads and reference the object on both threads.

JAL: /* Copy methods in SOUL system classes */ add note re collections

2017-01-23T21:34:54Z

Copy methods in SOUL system classes: add note re collections

← Older revision		Revision as of 21:34, 23 January 2017
Line 99:		Line 99:
	<li><var>[[XmlDoc class\|XmlDoc]]</var>		<li><var>[[XmlDoc class\|XmlDoc]]</var>
	</ul>		</ul>
			<p class="note"><b>Note:</b> Although collections themselves are deep copyable, a particular collection might contain references to non-deep-copyable objects, which disallows deep copy of that specific collection. </p>

	The following classes are deep copyable only:		The following classes are deep copyable only:
	<ul>		<ul>
Line 104:		Line 106:
	<li><var>[[XmlNode class\|XmlNode]]</var>		<li><var>[[XmlNode class\|XmlNode]]</var>
	</ul>		</ul>

	<p class="note"><b>Note:</b> Although collections themselves are deep copyable, a particular collection might contain references to non-deep-copyable objects, which disallows deep copy of that specific collection. </p>

	For the following classes, no copy methods are implemented, typically because of their complexity or their dependence on information that is not held in the objects themselves:		For the following classes, no copy methods are implemented, typically because of their complexity or their dependence on information that is not held in the objects themselves:

JAL: /* Copy methods in SOUL system classes */ add note re collections

2017-01-23T21:33:21Z

Copy methods in SOUL system classes: add note re collections

← Older revision		Revision as of 21:33, 23 January 2017
Line 89:		Line 89:
	<ul>		<ul>
	<li>All [[Enumerations\|enumerations]]		<li>All [[Enumerations\|enumerations]]
	<li>All [[Collections\|collections]]		<li>All [[Collections\|collections]] (see qualifying "Note," below this list)
	<li><var>[[CharacterMap class\|CharacterMap]]</var>		<li><var>[[CharacterMap class\|CharacterMap]]</var>
	<li><var>[[Json class\|Json]]</var>		<li><var>[[Json class\|Json]]</var>
Line 105:		Line 105:
	</ul>		</ul>

			<p class="note"><b>Note:</b> Although collections themselves are deep copyable, a particular collection might contain references to non-deep-copyable objects, which disallows deep copy of that specific collection. </p>

	For the following classes, no copy methods are implemented, typically because of their complexity or their dependence on information that is not held in the objects themselves:		For the following classes, no copy methods are implemented, typically because of their complexity or their dependence on information that is not held in the objects themselves:

JAL: /* Copy methods in SOUL system classes */ add Json class

2017-01-23T21:21:52Z

Copy methods in SOUL system classes: add Json class

← Older revision		Revision as of 21:21, 23 January 2017
Line 91:		Line 91:
	<li>All [[Collections\|collections]]		<li>All [[Collections\|collections]]
	<li><var>[[CharacterMap class\|CharacterMap]]</var>		<li><var>[[CharacterMap class\|CharacterMap]]</var>
			<li><var>[[Json class\|Json]]</var>
	<li><var>[[RandomNumberGenerator class\|RandomNumberGenerator]]</var>		<li><var>[[RandomNumberGenerator class\|RandomNumberGenerator]]</var>
	<li><var>[[Record class\|Record]]</var>, <var>[[Recordset class\|Recordset]]</var>, and <var>[[SortedRecordset class\|SortedRecordset]]</var>		<li><var>[[Record class\|Record]]</var>, <var>[[Recordset class\|Recordset]]</var>, and <var>[[SortedRecordset class\|SortedRecordset]]</var>

JAL at 17:31, 17 October 2013

2013-10-17T17:31:15Z

← Older revision		Revision as of 17:31, 17 October 2013
Line 1:		Line 1:
	~~The~~ <var class="product">~~[[Janus SOAP User Language Interface\|Janus SOAP ULI]]~~</var> includes generic (<var>Object</var> class) methods for making copies of <var class="product">User Language</var> class objects. "Shallow" and "deep" copying methods are available.		<var class="product">SOUL</var> includes generic (<var>Object</var> class) methods for making copies of <var class="product">User Language</var> class objects. "Shallow" and "deep" copying methods are available.

	The shallow and deep types of copy differ only in how they handle contained objects: A shallow copy of an object includes a copy of the references to its contained objects.		The shallow and deep types of copy differ only in how they handle contained objects: A shallow copy of an object includes a copy of the references to its contained objects.
Line 15:		Line 15:
	'''Shallow copies''' may be most useful with collections, say for sorting an <var>Arraylist</var>. To preserve the original order of a given <var>Arraylist</var>, you make a shallow copy of the collection to avoid the expense of making copies of any <var>Arraylist</var> objects, then you sort the shallow copy on whatever criterion you want. A shallow copy method may also in turn be used as a building block for constructing copy methods of arbitrary complexity for hierarchical object structures.		'''Shallow copies''' may be most useful with collections, say for sorting an <var>Arraylist</var>. To preserve the original order of a given <var>Arraylist</var>, you make a shallow copy of the collection to avoid the expense of making copies of any <var>Arraylist</var> objects, then you sort the shallow copy on whatever criterion you want. A shallow copy method may also in turn be used as a building block for constructing copy methods of arbitrary complexity for hierarchical object structures.

	'''Deep copies''' provide a facility for copying an entire arbitrarily complex object forest, and they are probably more widely useful than shallow copies. For example, deep copying is essential internally in ~~Sirius~~ system methods that let you pass an object between two threads and reference the object on both threads.		'''Deep copies''' provide a facility for copying an entire arbitrarily complex object forest, and they are probably more widely useful than shallow copies. For example, deep copying is essential internally in <var class="product">SOUL</var> system methods that let you pass an object between two threads and reference the object on both threads.

	==The Object class copy methods==		==The Object class copy methods==

	The <var>Object</var> class has two copy methods: <var>Copy</var> and <var>DeepCopy</var>. Both methods are functions without arguments that return a new instance of the method object to which they are applied.		The <var>Object</var> class has two copy methods: <var>Copy</var> and <var>DeepCopy</var>. Both methods are functions without arguments that return a new instance of the method object to which they are applied.
	<p class="code">%cop = %obj:Copy		<p class="code">%cop = %obj:Copy
Line 30:		Line 29:
	<dd>A deep copy (member by member assignment plus duplication of any referenced objects) of its method object %obj.		<dd>A deep copy (member by member assignment plus duplication of any referenced objects) of its method object %obj.
	<dt>%obj		<dt>%obj
	<dd>A shallow or deep "copyable" <var class="product">~~User Language~~</var> object. The Public block of such an object's class must include the Allow Copy, AllowDeepCopy, or both keywords to make available the Copy, DeepCopy, or both methods. You specify these keywords as you would a method declaration (see [[Classes and Objects#Declaration blocks\|Declaration blocks]]), but the method is provided by the system rather than the class programmer. Whether an object is shallow or deep copyable is discussed further below.		<dd>A shallow or deep "copyable" <var class="product">SOUL</var> object. The <var>Public</var> block of such an object's class must include the <var>Allow Copy</var>, <var>AllowDeepCopy</var>, or both keywords to make available the <var>Copy</var>, <var>DeepCopy</var>, or both methods. You specify these keywords as you would a method declaration (see [[Classes and Objects#Declaration blocks\|Declaration blocks]]), but the method is provided by the system rather than the class programmer. Whether an object is shallow or deep copyable is discussed further below.
	</dl>		</dl>

	===Usage Notes===		===Usage Notes===
	<ul>		<ul>
	<li>Not all objects may be copied. For example, a ~~Sirius~~ <var>Socket</var> object is an example of a class that is not shallow or deep copyable, because it has a significant amount of information or state that is not held in the object itself. And what does it mean to copy a network connection?		<li>Not all objects may be copied. For example, a <var class="product">SOUL</var> <var>Socket</var> object is an example of a class that is not shallow or deep copyable, because it has a significant amount of information or state that is not held in the object itself. And what does it mean to copy a network connection?

	<li>Not all objects that it is possible to copy should be allowed to be copied. As a general rule of thumb, any object that holds information external to its own public or private variables is a good candidate for not being allowed to be shallow or deep copyable. For example, consider a class that is used to manage a record. Object private variables might be dependent on the contents of the record, but if you have multiple instances of the object and the class updates the record, the private variables in one instance could end up out of synch with the record due to updates by another source.		<li>Not all objects that it is possible to copy should be allowed to be copied. As a general rule of thumb, any object that holds information external to its own public or private variables is a good candidate for not being allowed to be shallow or deep copyable. For example, consider a class that is used to manage a record. Object private variables might be dependent on the contents of the record, but if you have multiple instances of the object and the class updates the record, the private variables in one instance could end up out of synch with the record due to updates by another source.
	<li>For an object to be shallow or deep copyable, all it's contained objects must themselves be shallow or deep copyable, respectively. The compiler ensures that if an object's class contains an object member (or an object member contained in that object member's "descendant objects,") whose class definition does not specify <code>Allow Copy</code> or <code>Allow DeepCopy</code>, the original object is not shallow or deep copyable, respectively.<br />The ~~Sirius~~ system classes that are shallow or deep copyable are specified in the following section.
			<li>For an object to be shallow or deep copyable, all it's contained objects must themselves be shallow or deep copyable, respectively. The compiler ensures that if an object's class contains an object member (or an object member contained in that object member's "descendant objects,") whose class definition does not specify <code>Allow Copy</code> or <code>Allow DeepCopy</code>, the original object is not shallow or deep copyable, respectively.<br />The <var class="product">SOUL</var> system classes that are shallow or deep copyable are specified in the following section.

	<li>Allow <var>DeepCopy</var> does not imply <var>Allow Copy</var>. However, [[#Inheritance and polymorphism\|inheritance]] permits an <var>Allow Copy</var> designated class to have its own <var>Copy</var> method defined, and it permits an <var>Allow DeepCopy</var> designated class to have its own <var>DeepCopy</var> method.		<li>Allow <var>DeepCopy</var> does not imply <var>Allow Copy</var>. However, [[#Inheritance and polymorphism\|inheritance]] permits an <var>Allow Copy</var> designated class to have its own <var>Copy</var> method defined, and it permits an <var>Allow DeepCopy</var> designated class to have its own <var>DeepCopy</var> method.
	<li>For all <var>Copy</var> and <var>DeepCopy</var> methods (system or generic <var class="product">~~User Language~~</var>), the method object may be null (internally, it is defined with the <var>AllowNull</var> keyword). The output of a copy of a null object is a null object.
	<li>If a user-defined class already has a method called Copy (or DeepCopy), it does not conflict with the <var>Object</var> class <var>Copy</var> (or <var>DeepCopy</var>) method. However, due to inheritance, the user class <~~var~~>Copy</~~var~~> definition must specify that it is an override.		<li>For all <var>Copy</var> and <var>DeepCopy</var> methods (system or generic <var class="product">SOUL</var>), the method object may be null (internally, it is defined with the <var>AllowNull</var> keyword). The output of a copy of a null object is a null object.

			<li>If a user-defined class already has a method called <code>Copy</code> (or <code>DeepCopy</code>), it does not conflict with the <var>Object</var> class <var>Copy</var> (or <var>DeepCopy</var>) method. However, due to inheritance, the user class <code>Copy</code> definition must specify that it is an override.
	</ul>		</ul>

Line 78:		Line 83:
	... do things with %b		... do things with %b
	</p>		</p>
	==Copy methods in ~~the Sirius~~ system classes==
	The following ~~Sirius~~ system classes are shallow and deep copyable, that is, they include both <var>Copy</var> and <var>DeepCopy</var> methods. In the classes that contain no object members, the <var>Copy</var> and <var>DeepCopy</var> methods are the same:		==Copy methods in SOUL system classes==
			The following system classes are shallow and deep copyable, that is, they include both <var>Copy</var> and <var>DeepCopy</var> methods. In the classes that contain no object members, the <var>Copy</var> and <var>DeepCopy</var> methods are the same:

	<ul>		<ul>
Line 121:		Line 127:
	</ul>		</ul>

	As described in [[#The Object class copy methods\|"The Object class copy methods"]], the presence or absence		As described in [[#The Object class copy methods\|The Object class copy methods]], the presence or absence
	of the <var>Copy</var> and <var>DeepCopy</var> methods in the system classes affects the degree of copyability		of the <var>Copy</var> and <var>DeepCopy</var> methods in the system classes affects the degree of copyability
	of any ~~<var class="product">User Language</var>~~ classes that contain objects of these system classes.		of any user-defined classes that contain objects of these system classes.
	A ~~<var class="product">User Language</var>~~ class that contains a <var>~~Daemon class\|~~Daemon</var> object, for example,		A user class that contains a <var>Daemon</var> object, for example,
	is not deep copyable. A ~~<var class="product">User Language</var>~~ class that contains a <var>Stringlist</var>,		is not deep copyable. A user class that contains a <var>Stringlist</var>,
	though, may be shallow or deep copied, subject to the copyability of the other members of the class.		though, may be shallow or deep copied, subject to the copyability of the other members of the class.

	The deep copyability of the individual ~~Sirius~~ system classes also determines the objects that are eligible to be used with ~~Sirius~~ system <var>Daemon</var> objects. Only objects that are deep copyable may be passed to and retrieved from <var>Daemon</var> objects, which may be called by a <var class="product">~~User Language~~</var> program to execute commands on a separate thread.		The deep copyability of the individual SOUL system classes also determines the objects that are eligible to be used with system <var>Daemon</var> objects. Only objects that are deep copyable may be passed to and retrieved from <var>Daemon</var> objects, which may be called by a <var class="product">SOUL</var> program to execute commands on a separate thread.

	==See also==		==See also==

JAL: /* See also */

2013-10-14T22:10:02Z

JALWiccan: Automatically generated page update

2013-10-14T20:05:20Z

Automatically generated page update

← Older revision		Revision as of 20:05, 14 October 2013
Line 140:		Line 140:
	</ul>		</ul>

	[[Category:~~Janus SOAP ULI~~ topics]]		[[Category:SOUL object-oriented programming topics]]

JALWiccan: Automatically generated page update

2013-06-03T21:28:58Z

Automatically generated page update

New page

The <var class="product">[[Janus SOAP User Language Interface|Janus SOAP ULI]]</var> includes generic (<var>Object</var> class) methods for making copies of <var class="product">User Language</var> class objects. "Shallow" and "deep" copying methods are available.

The shallow and deep types of copy differ only in how they handle contained objects: A shallow copy of an object includes a copy of the references to its contained objects.
A deep copy includes the references to its contained objects and it includes a copy of the referenced object
itself —
and if a contained object itself contains objects, deep copy copies those references and objects, and if any of those objects have contained objects, deep copying continues like this until the chain of objects contained in contained objects is exhausted.

For example, if a simple object (%S) contains multiple variable members, one of which is an object variable(%c, which references an object that has no contained object variables),
a shallow copy produces a matching object with matching variable members, including %c.
Remembering that %c is a reference and not the actual object, the shallow copy of an object that contains an object pointer thus produces a matching object and object pointer.
A deep copy of %S produces two objects: one object that matches %S with a pointer to %c, and one object that is a replica of the actual object that %c references.

For simple objects (objects without contained objects), a shallow copy is the same as a deep copy.

'''Shallow copies''' may be most useful with collections, say for sorting an <var>Arraylist</var>. To preserve the original order of a given <var>Arraylist</var>, you make a shallow copy of the collection to avoid the expense of making copies of any <var>Arraylist</var> objects, then you sort the shallow copy on whatever criterion you want. A shallow copy method may also in turn be used as a building block for constructing copy methods of arbitrary complexity for hierarchical object structures.

'''Deep copies''' provide a facility for copying an entire arbitrarily complex object forest, and they are probably more widely useful than shallow copies. For example, deep copying is essential internally in Sirius system methods that let you pass an object between two threads and reference the object on both threads.

==The Object class copy methods==

The <var>Object</var> class has two copy methods: <var>Copy</var> and <var>DeepCopy</var>. Both methods are functions without arguments that return a new instance of the method object to which they are applied.
%cop = %obj:Copy
%dcop = %obj:DeepCopy 

Where:
<dl>
<dt>%cop
<dd>A shallow copy (member variable by member variable assignment) of method object %obj.
<dt>%dcop
<dd>A deep copy (member by member assignment plus duplication of any referenced objects) of its method object %obj.
<dt>%obj
<dd>A shallow or deep "copyable" <var class="product">User Language</var> object. The Public block of such an object's class must include the Allow Copy, AllowDeepCopy, or both keywords to make available the Copy, DeepCopy, or both methods. You specify these keywords as you would a method declaration (see [[Classes and Objects#Declaration blocks|Declaration blocks]]), but the method is provided by the system rather than the class programmer. Whether an object is shallow or deep copyable is discussed further below.
</dl>
===Usage Notes===
<ul>
<li>Not all objects may be copied. For example, a Sirius <var>Socket</var> object is an example of a class that is not shallow or deep copyable, because it has a significant amount of information or state that is not held in the object itself. And what does it mean to copy a network connection?
<li>Not all objects that it is possible to copy should be allowed to be copied. As a general rule of thumb, any object that holds information external to its own public or private variables is a good candidate for not being allowed to be shallow or deep copyable. For example, consider a class that is used to manage a record. Object private variables might be dependent on the contents of the record, but if you have multiple instances of the object and the class updates the record, the private variables in one instance could end up out of synch with the record due to updates by another source.
<li>For an object to be shallow or deep copyable, all it's contained objects must themselves be shallow or deep copyable, respectively. The compiler ensures that if an object's class contains an object member (or an object member contained in that object member's "descendant objects,") whose class definition does not specify <code>Allow Copy</code> or <code>Allow DeepCopy</code>, the original object is not shallow or deep copyable, respectively. The Sirius system classes that are shallow or deep copyable are specified in the following section.
<li>Allow <var>DeepCopy</var> does not imply <var>Allow Copy</var>. However, [[#Inheritance and polymorphism|inheritance]] permits an <var>Allow Copy</var> designated class to have its own <var>Copy</var> method defined, and it permits an <var>Allow DeepCopy</var> designated class to have its own <var>DeepCopy</var> method.
<li>For all <var>Copy</var> and <var>DeepCopy</var> methods (system or generic <var class="product">User Language</var>), the method object may be null (internally, it is defined with the <var>AllowNull</var> keyword). The output of a copy of a null object is a null object.
<li>If a user-defined class already has a method called Copy (or DeepCopy), it does not conflict with the <var>Object</var> class <var>Copy</var> (or <var>DeepCopy</var>) method. However, due to inheritance, the user class <var>Copy</var> definition must specify that it is an override.
</ul>

===Example===
The following fragment sketches a deep copyable user class that contains two objects. The contained objects contain no further object references, but they are both subject to update from an external source. The class designer wants instances of the class to be deep copyable only, so class object copies are insulated from external changes to its constituent objects. A shallow copy of a class object, with pointers to its contained objects, would be modified upon changes to its contained objects.
class latitude
public
allow deepcopy
...
end public
...
end class latitude
class longitude
public
allow deepcopy
...
end public
...
end class longitude
class point
public
allow deepcopy
property latitude is object latitude readonly
property longitude is object longitude readonly
...
end public
private
variable xlat is object latitude
variable xlong is object longitude
end private
...
end class point
%a is object point
%b is object point
%a = new
... do things with %a
%b = %a:deepcopy
... do things with %b

==Copy methods in the Sirius system classes==
The following Sirius system classes are shallow and deep copyable, that is, they include both <var>Copy</var> and <var>DeepCopy</var> methods. In the classes that contain no object members, the <var>Copy</var> and <var>DeepCopy</var> methods are the same:

<ul>
<li>All [[Enumerations|enumerations]]
<li>All [[Collections|collections]]
<li><var>[[CharacterMap class|CharacterMap]]</var>
<li><var>[[RandomNumberGenerator class|RandomNumberGenerator]]</var>
<li><var>[[Record class|Record]]</var>, <var>[[Recordset class|Recordset]]</var>, and <var>[[SortedRecordset class|SortedRecordset]]</var>
<li><var>[[Screen class|Screen]]</var>
<li><var>[[Stringlist class|Stringlist]]</var>
<li><var>[[UserStatistics class|UserStatistics]]</var>
<li><var>[[XmlDoc class|XmlDoc]]</var>
</ul>
The following classes are deep copyable only:
<ul>
<li><var>[[ScreenField class|ScreenField]]</var>
<li><var>[[XmlNode class|XmlNode]]</var>
</ul>

For the following classes, no copy methods are implemented, typically because of their complexity or their dependence on information that is not held in the objects themselves:

<ul>
<li>All [[Intrinsic classes|intrinsics]]
<li>All [[Exceptions|exceptions]]
<li><var>[[Daemon class|Daemon]]</var>
<li><var>[[Dataset class|Dataset]]</var>
<li><var>[[Email class|Email]]</var>
<li><var>[[FastUnloadTask class|FastUnloadTask]]</var>
<li><var>[[HttpRequest class|HttpRequest]]</var> and <var>[[HttpResponse class|HttpResponse]]</var> (HTTP Helper)
<li><var>[[Journal class|Journal]]</var>
<li><var>[[LDAP class|LDAP]]</var>
<li><var>[[PersistentObjectInfo class|PersistentObjectInfo]]</var>
<li><var>[[RecordsetCursor class|RecordsetCursor]]</var>
<li><var>[[Socket class|Socket]]</var>
<li><var>[[SortOrder class|SortOrder]]</var>
<li><var>[[SelectionCriterion class|SelectionCriterion]]</var>
<li><var>[[StringTokenizer class|StringTokenizer]]</var>
<li><var>[[System class|System]]</var> and <var>[[Subsystem class|Subsystem]]</var>
<li><var>[[XmlParser class|XmlParser]]</var>
<li><var>[[XmlNodelist class|XmlNodelist]]</var>
</ul>

As described in [[#The Object class copy methods|"The Object class copy methods"]], the presence or absence
of the <var>Copy</var> and <var>DeepCopy</var> methods in the system classes affects the degree of copyability
of any <var class="product">User Language</var> classes that contain objects of these system classes.
A <var class="product">User Language</var> class that contains a <var>Daemon class|Daemon</var> object, for example,
is not deep copyable. A <var class="product">User Language</var> class that contains a <var>Stringlist</var>,
though, may be shallow or deep copied, subject to the copyability of the other members of the class.

The deep copyability of the individual Sirius system classes also determines the objects that are eligible to be used with Sirius system <var>Daemon</var> objects. Only objects that are deep copyable may be passed to and retrieved from <var>Daemon</var> objects, which may be called by a <var class="product">User Language</var> program to execute commands on a separate thread.

==See also==
<ul>
<li>[[Classes and Objects]]
<li>[[Object variables]]
<li>[[Global and session objects]]
<li>[[Managing server space for objects]]
<li>[[Methods]]
<li>[[Janus SOAP ULI essentials]]
</ul>

[[Category:Janus SOAP ULI topics]]

JAL2: /* See also */

2012-01-11T17:44:13Z

← Older revision		Revision as of 22:10, 14 October 2013
Line 137:		Line 137:
	<li>[[Managing server space for objects]]		<li>[[Managing server space for objects]]
	<li>[[Methods]]		<li>[[Methods]]
	<li>[[~~Janus SOAP ULI essentials~~]]		<li>[[Object oriented programming in SOUL]]
	</ul>		</ul>

	[[Category:SOUL object-oriented programming topics]]		[[Category:SOUL object-oriented programming topics]]

← Older revision		Revision as of 17:44, 11 January 2012
Line 137:		Line 137:
	<li>[[Managing server space for objects]]		<li>[[Managing server space for objects]]
	<li>[[Methods]]		<li>[[Methods]]
	~~<li>[[Lists of classes and methods]]~~		<li>[[Janus SOAP essentials]]
	<li>[[Janus SOAP ~~User Language Interface\|Janus SOAP ULI]]~~
	~~<li>[[Getting started with object-oriented programming for User Language programmers~~]]
	</ul>		</ul>

	[[Category:Janus SOAP ULI topics]]		[[Category:Janus SOAP ULI topics]]