Object variables - Revision history

Dme: /* Passing object variables as parameters */

2018-08-15T19:05:49Z

Passing object variables as parameters

← Older revision		Revision as of 19:05, 15 August 2018
Line 906:		Line 906:
	</p>		</p>

	<blockquote class="note">'''Note:''' A case where a method significantly affects the object referenced by		<blockquote class="note">'''Note:''' A case where a method significantly affects the object referenced by an Input object variable is the Discard method.
	an Input object variable is the Discard method.
	A Discard method invoked against an Input parameter sets		A Discard method invoked against an Input parameter sets
	the Input parameter and call argument to Null.		the Input parameter and call argument to Null.

Tbullock: '' to avoid italics

2015-10-29T23:16:56Z

'' to avoid italics

← Older revision		Revision as of 23:16, 29 October 2015
Line 69:		Line 69:
	%fluffy:type = 'Dog'		%fluffy:type = 'Dog'
	if %fluffy eq %rover then		if %fluffy eq %rover then
	print 'They''re equal!'		print 'They''re equal!'
	end if		end if
	</p>		</p>
Line 91:		Line 91:
	%rover = %fluffy		%rover = %fluffy
	if %fluffy eq %rover then		if %fluffy eq %rover then
	print 'They''re equal!'		print 'They''re equal!'
	end if		end if
	</p>		</p>

Dme: /* Virtual Constructor methods */

2015-08-14T17:46:08Z

Virtual Constructor methods

← Older revision		Revision as of 17:46, 14 August 2015
Line 327:		Line 327:
	<var>Public</var> block.		<var>Public</var> block.

	===Virtual Constructor methods===		===<b id="Virtual Constructor methods"></b>Virtual constructors===
	It is possible to have a non-constructor shared function return an		It is possible to have a non-constructor shared function return an
	instance of a class:		instance of a class:

JAL: /* Why use an object reference instead of an object */

2013-12-17T00:43:36Z

Why use an object reference instead of an object

← Older revision		Revision as of 00:43, 17 December 2013
Line 25:		Line 25:
	The following is an example of assignment of an object reference, rather		The following is an example of assignment of an object reference, rather
	than an object:		than an object:
	<~~pre~~>
	class pet		<p class="code">class pet
	public		public
	variable type is string len 16		variable type is string len 16
Line 39:		Line 39:
	%fluffy:type = 'Cat'		%fluffy:type = 'Cat'
	print %rover:type		print %rover:type
	</~~pre~~>		</p>

	Because the statement <code>%fluffy = %rover</code> assigns to %fluffy a reference		Because the statement <code>%fluffy = %rover</code> assigns to %fluffy a reference
	to the same object as %rover, both variables end up referring		to the same object as %rover, both variables end up referring
Line 54:		Line 55:

	Consider the following example::		Consider the following example::
	<~~pre~~>		<p class="code">class pet
	class pet
	public		public
	variable type is string len 16		variable type is string len 16
Line 71:		Line 71:
	print 'They''re equal!'		print 'They''re equal!'
	end if		end if
	</~~pre~~>		</p>

	This will not print <code>They're equal</code>.		This will not print <code>They're equal</code>.
	Even though the objects		Even though the objects
Line 77:		Line 78:
	are different objects, so %fluffy is not equal to %rover.		are different objects, so %fluffy is not equal to %rover.
	However, if the code were changed:		However, if the code were changed:
	<~~pre~~>
	class pet		<p class="code">class pet
	public		public
	variable type is string len 16		variable type is string len 16
Line 92:		Line 93:
	print 'They''re equal!'		print 'They''re equal!'
	end if		end if
	</~~pre~~>		</p>

	<code>They're equal</code> will be printed, because <code>%rover = %fluffy</code>		<code>They're equal</code> will be printed, because <code>%rover = %fluffy</code>
	sets <code>%rover</code> to point to the same object as <code>%fluffy</code>, making them equal.		sets <code>%rover</code> to point to the same object as <code>%fluffy</code>, making them equal.
	<br>'''Note:'''
			<p class="note>'''Note:'''
	Since order comparisons (GE, LE, GT, and LT) are meaningless for references —		Since order comparisons (GE, LE, GT, and LT) are meaningless for references —
	when is a reference to one object greater than a reference to another? —		when is a reference to one object greater than a reference to another? —
	only equality and inequality (EQ and NE) comparisons are allowed for objects.		only equality and inequality (EQ and NE) comparisons are allowed for objects. </p>

	Despite the foregoing remarks, for most purposes, one can still think of		Despite the foregoing remarks, for most purposes, one can still think of
Line 104:		Line 107:
	the objects themselves, rather than references to the object.		the objects themselves, rather than references to the object.
	For example, in the statement:		For example, in the statement:
	<~~pre~~>
	%rover:type = 'Ferret'		<p class="code">%rover:type = 'Ferret'
	</~~pre~~>		</p>

	it is quite natural to think of the statement as setting %rover's Type to		it is quite natural to think of the statement as setting %rover's Type to
	"ferret," rather than as setting the type of the object referenced		"ferret," rather than as setting the type of the object referenced

JAL: /* Creating object instances */

2013-12-17T00:40:45Z

Creating object instances

← Older revision		Revision as of 00:40, 17 December 2013
Line 112:		Line 112:

	==Creating object instances==		==Creating object instances==

	Since object variables are references to objects, two questions naturally		Since object variables are references to objects, two questions naturally
	arise: what object does an object variable refer to initially, and		arise: what object does an object variable refer to initially, and
Line 119:		Line 118:
	points to ''no'' object.		points to ''no'' object.
	So, the following program would cause a request cancellation error:		So, the following program would cause a request cancellation error:
	<~~pre~~>
	class pet		<p class="code">class pet
	public		public
	variable type is string len 16		variable type is string len 16
Line 129:		Line 128:

	%rover:type = 'Dog'		%rover:type = 'Dog'
	</~~pre~~>		</p>

	The statement <code>%rover:type = 'Dog'</code> attempts to set the object's		The statement <code>%rover:type = 'Dog'</code> attempts to set the object's
	type to "Dog," but there is no instance of an object for		type to "Dog," but there is no instance of an object for
Line 144:		Line 144:
	<li>Operates on the new instance (which is the value of <code>%this</code> within the <var>Constructor</var>)		<li>Operates on the new instance (which is the value of <code>%this</code> within the <var>Constructor</var>)
	<p>Unlike a shared method, a <var>Constructor</var> operates on an object instance.</p>		<p>Unlike a shared method, a <var>Constructor</var> operates on an object instance.</p>

	<li>Returns the value of <code>%this</code> as the result.		<li>Returns the value of <code>%this</code> as the result.
	<p>		<p>
	Like a <var>Subroutine</var>, the <var>Constructor</var>'s <var>Return</var> statement may not specify a value, but like a <var>Function</var>, the <var>Constructor</var> does produce a result.</p>		Like a <var>Subroutine</var>, the <var>Constructor</var>'s <var>Return</var> statement may not specify a value, but like a <var>Function</var>, the <var>Constructor</var> does produce a result.</p>
	</ul>		</ul>
	In any non-<var>[[Dynamic dispatch#Overridable versus Abstract methods\|Abstract]]</var> class, you can invoke a default <var>Constructor</var>, named <var>New</var>, which operates no further on <code>%this</code> and simply returns a new instance for explicit or implicit assignment. As described below, you can explicitly define <var>New</var> to operate on the new instance, you can define other constructors in addition to New, and you can also [[#Private constructors\|"disallow"]] New from use outside the class definition.
			In any non-<var>[[Dynamic dispatch#Overridable versus Abstract methods\|Abstract]]</var> class, you can invoke a default <var>Constructor</var>, named <var>New</var>, which operates no further on <code>%this</code> and simply returns a new instance for explicit or implicit assignment. As described below, you can explicitly define <var>New</var> to operate on the new instance, you can define other constructors in addition to <var>New</var>, and you can also [[#Private constructors\|"disallow"]] <var>New</var> from use outside the class definition.

	====Syntax for Constructors====		====Syntax for Constructors====
Line 354:		Line 356:
	<li>They might not actually instantiate an object but return a reference to an existing instance. Such a method may not truly be a factory method.		<li>They might not actually instantiate an object but return a reference to an existing instance. Such a method may not truly be a factory method.
	</ul>		</ul>
	The support for multiple constructors means that <var class="product">~~Janus SOAP User Language Interface~~</var>		The support for multiple constructors means that <var class="product">SOUL</var>
	users need factory methods less than those using		users need factory methods less than those using
	most other object-oriented programming languages.		most other object-oriented programming languages.

JAL: /* Using New or other Constructors */

2013-12-17T00:36:29Z

Using New or other Constructors

← Older revision		Revision as of 00:36, 17 December 2013
Line 140:		Line 140:

	===Using New or other Constructors===		===Using New or other Constructors===
	When you invoke a <var>Constructor</var> method, ~~the~~ <var class="product">~~Janus SOAP ULI~~</var> creates an object instance which is available to the <var>Constructor</var> code. The <var>Constructor</var>:		When you invoke a <var>Constructor</var> method, <var class="product">SOUL</var> creates an object instance which is available to the <var>Constructor</var> code. The <var>Constructor</var>:
	<ul>		<ul>
	<li>Operates on the new instance (which is the value of <code>%this</code> within the <var>Constructor</var>)		<li>Operates on the new instance (which is the value of <code>%this</code> within the <var>Constructor</var>)

JAL: /* Using multiple Constructors */

2013-12-17T00:35:32Z

Using multiple Constructors

← Older revision		Revision as of 00:35, 17 December 2013
Line 276:		Line 276:
	parameter list.		parameter list.

	~~The~~ <var class="product">~~Janus SOAP User Language Interface~~</var> supports '''multiple constructors''':		<var class="product">SOUL</var> supports '''multiple constructors''':
	<p class="code">class resource		<p class="code">class resource
	public		public

JAL: /* Virtual Constructor methods */

2013-12-17T00:34:33Z

Virtual Constructor methods

← Older revision		Revision as of 00:34, 17 December 2013
Line 322:		Line 322:

	===Virtual Constructor methods===		===Virtual Constructor methods===

	It is possible to have a non-constructor shared function return an		It is possible to have a non-constructor shared function return an
	instance of a class:		instance of a class:
	<~~pre~~>
	class resource		<p class="code">class resource
	public shared		public shared
	function newFromUrl(%url is string len 255) -		function newFromUrl(%url is string len 255) -
Line 345:		Line 344:
	...		...
	%res = %res:newFromUrl('http://nfl.com/score')		%res = %res:newFromUrl('http://nfl.com/score')
	</~~pre~~>		</p>

	Such functions are often called '''factory methods''' or		Such functions are often called '''factory methods''' or
	virtual constructors.		virtual constructors.
Line 360:		Line 360:
	Virtual constructors can be invoked in much the same way that regular constructors are invoked, that is, without specifying the class name if the class name can be determined from context.		Virtual constructors can be invoked in much the same way that regular constructors are invoked, that is, without specifying the class name if the class name can be determined from context.
	For example, the above example of the NewFromUrl virtual constructor can be changed to the following:		For example, the above example of the NewFromUrl virtual constructor can be changed to the following:
	<~~pre~~>
	%res is object resource		<p class="code">%res is object resource
	...		...
	%res = newFromUrl('http://nfl.com/score')		%res = newFromUrl('http://nfl.com/score')
	</~~pre~~>		</p>

	Similarly, if a method called Send in class Coworker took a resource		Similarly, if a method called Send in class Coworker took a resource
	object as an input parameter, the NewFromUrl virtual constructor could		object as an input parameter, the NewFromUrl virtual constructor could
	also be used as follows:		also be used as follows:
	<~~pre~~>
	%sufjan is object coworker		<p class="code">%sufjan is object coworker
	...		...
	%sufjan:send(newFromUrl('http://asthmatickitty.com'))		%sufjan:send(newFromUrl('http://asthmatickitty.com'))
	</~~pre~~>		</p>

	Because the naming rules for virtual constructors are now		Because the naming rules for virtual constructors are now

JAL: /* Object variables within class definitions */

2013-12-17T00:33:11Z

Object variables within class definitions

← Older revision		Revision as of 00:33, 17 December 2013
Line 380:		Line 380:

	==Object variables within class definitions==		==Object variables within class definitions==

	Classes can, themselves, contain object variables:		Classes can, themselves, contain object variables:
	<~~pre~~>		<p class="code">class pet
	class pet
	public		public
	...		...
Line 391:		Line 389:
	...		...
	end class		end class
	</~~pre~~>		</p>

	Remember that an object variable is not really the object itself but		Remember that an object variable is not really the object itself but
	a reference to an underlying object so, in the case of an object		a reference to an underlying object so, in the case of an object
Line 397:		Line 396:
	object, per se, but simply a reference to another object.		object, per se, but simply a reference to another object.

	It is possible for two different classes to each contain references		It is possible for two different classes to each contain references to each other.
	to each other.
	But for an object variable to be defined, the object class must already have		But for an object variable to be defined, the object class must already have
	been declared.		been declared.
Line 404:		Line 402:
	be declared without the references before the other.		be declared without the references before the other.
	The simplest way to do this is with an empty Class block:		The simplest way to do this is with an empty Class block:
	<~~pre~~>
	class human		<p class="code">class human
	end class		end class

Line 425:		Line 423:
	...		...
	end class		end class
	</~~pre~~>		</p>

	It is also possible for a class to contain object variables that		It is also possible for a class to contain object variables that
	refer to the containing class:		refer to the containing class:
	<~~pre~~>		<p class="code">class pet
	class pet
	public		public
	...		...
Line 437:		Line 435:
	...		...
	end class		end class
	</~~pre~~>		</p>
	In such a case, no empty Class block is necessary to declare the class
	because the Class block containing the object variable is sufficient		In such a case, no empty <var>Class</var> block is necessary to declare the class
			because the <var>Class</var> block containing the object variable is sufficient
	to declare the existence of the class.		to declare the existence of the class.

	==Discarding objects==		==Discarding objects==

JAL: /* Discarding explicitly */

2013-12-17T00:30:54Z

Discarding explicitly

← Older revision		Revision as of 00:30, 17 December 2013
Line 450:		Line 450:
	An underlying object can be discarded explicitly by invoking the <var>Discard</var>		An underlying object can be discarded explicitly by invoking the <var>Discard</var>
	method (system subroutine) against it:		method (system subroutine) against it:
	<~~pre~~>
	%mick is object dog		<p class="code">%mick is object dog
	...		...
	%mick = new('Terrier')		%mick = new('Terrier')
Line 457:		Line 457:
	* Done with object pointed to by %mick		* Done with object pointed to by %mick
	%mick:discard		%mick:discard
	</~~pre~~>		</p>

	The Discard method never takes any input parameters and returns no value,		The Discard method never takes any input parameters and returns no value,
	so it is a Subroutine.		so it is a Subroutine.
	The Discard method is an AllowNullObject method because it can be invoked		The Discard method is an AllowNullObject method because it can be invoked
	with a null object, such as one that was never set:		with a null object, such as one that was never set:
	<~~pre~~>
	%mick is object dog		<p class="code">%mick is object dog

	for %i from 1 to 10		for %i from 1 to 10
Line 469:		Line 470:
	...		...
	end for		end for
	</~~pre~~>		</p>

	In the first loop iteration, above, <code>%mick</code> would not be set, so the		In the first loop iteration, above, <code>%mick</code> would not be set, so the
	<code>%mick:discard</code> call would not have anything to discard,		<code>%mick:discard</code> call would not have anything to discard,
	but it would not indicate a request-cancelling null-pointer error.		but it would not indicate a request-cancelling null-pointer error.

	'''Note:''' Not all objects may be discarded explicitly:		<blockquote class="note">
			<p>'''Note:''' Not all objects may be discarded explicitly: </p>
	<ul>		<ul>
	<li>Some objects are integral parts of other objects, and discarding one cannot be done without compromising the other. For example, you may not explicitly <var>Discard</var> an XmlNode object, though as discussed [[#xmlnode\|below]], you may discard it by using the <var>DeepDiscard</var> method.		<li>Some objects are integral parts of other objects, and discarding one cannot be done without compromising the other. For example, you may not explicitly <var>Discard</var> an XmlNode object, though as discussed [[#xmlnode\|below]], you may discard it by using the <var>DeepDiscard</var> method.
	<li>Some objects may be explicitly defined with a <var>[[Classes and Objects#Disallow clause\|Disallow Discard]]</var> clause, which protects them from being discarded directly.		<li>Some objects may be explicitly defined with a <var>[[Classes and Objects#Disallow clause\|Disallow Discard]]</var> clause, which protects them from being discarded directly.
	</ul>		</ul>
			</blockquote>

	===Discarding implicitly===		===Discarding implicitly===
	Objects may be discarded implicitly, when there are no		Objects may be discarded implicitly, when there are no