1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="GENERATOR" content="Mozilla/4.61 [en] (X11; I; Linux 2.2.11 i686) [Netscape]">
<title>stooop switched class</title>
</head>
<body>
<center>
<dt>
<b><font size=+4>the switched class</font></b></dt></center>
<p>
<br>
<br>
<p>The <b>switched</b> class serves as base class for user classes with
switch / option configuration method. It provides facilities for managing
options through a simple interface.
<p>For example:
<pre>set vehicle [new car -length 4.5 -width 2 -power 100 -fuel diesel]
puts "my car was running on [switched::cget $vehicle -fuel]"
switched::configure $vehicle -power 40 -fuel electricity
puts "but is now running on clean [switched::cget $vehicle -fuel]"</pre>
Of course, as you might have guessed, the <b>car</b> class is derived from
the <b>switched</b> class. Let us see how it works:
<pre>class car {
proc car {this args} switched {$args} {
# car specific initialization code here
switched::complete $this
}
...
}</pre>
The switched class constructor takes the optional configuration option
/ value pairs as parameters. The switched class layer then completely manages
the switched options: it checks their validity, stores their values and
provides a clean interface to the user layer configuration setting procedures.
<p>The switched class members available to the programmer are:
<p><b>switched</b>
<ul>
<li>
complete{}</li>
<li>
<i>options{}</i></li>
<li>
<i>set-option{}</i></li>
<li>
...</li>
<li>
complete</li>
<li>
-option</li>
<li>
...</li>
</ul>
The <b>complete</b> procedure is used to tell the switched layer that the
derived class object (a car in the examples) is completely built. At that
time, the initial configuration of the switched object occurs, using default
option values (see <b>options</b> procedure) eventually overridden by construction
time values, passed at the time of the <i>new</i> operator invocation.
The complete procedure must be called once only, usually around or at the
end of the derived class constructor. <i>(<b>Note</b>: also check the <b>complete</b>
data member later in this chapter)</i>
<p>The <b>options</b> procedure must return the configuration description
for <b>all</b> options that the switched object will accept. It is a pure
virtual member procedure and therefore its implementation is <b>mandatory</b>
in the derived class layer. The procedure must return a list of lists.
Each list pertains to a single option and is composed of the switch name,
the default value for the option and an optional initial value. For example:
<pre>class car {
...
proc options {this} {
return [list\
[list -fuel petrol petrol]\
[list -length {} {}]\
[list -power {} {}]\
[list -width {} {}]\
]
}
proc set-fuel {this value} {
...
}
...
}</pre>
In this case, 4 options are specified: <i>fuel</i>, <i>length</i>, <i>power</i>
and <i>width</i>. The default and initial values for the <i>fuel</i> option
are identical and set to <i>petrol</i>. For the other options, values are
all empty.
<p>For each option, there must be a corresponding set-<i>option</i> procedure
defined in the derived class layer. For example, since we defined a <i>fuel</i>
option, there is a set-<i>fuel</i> procedure in the car class. The parameters
always are the object identifier (since this is not a static procedure,
but rather a dynamically defined virtual one), followed by the new value
for the option. The set-<i>option</i> procedure is only invoked if the
new value differs from the current one (a cache scheme for improving performance),
or if there is no initial value set in the options procedure for that option.
<p>In the options procedure, if the initial value differs from the
default value or is omitted, then initial configuration is forced and the
corresponding set-<i>option</i> procedure is invoked by the switched <i>complete</i>
procedure located at the end of the derived class constructor. For example:
<pre>class car {
...
proc options {this} {
return [list\
[list -fuel petrol]\
[list -length {} {}]\
[list -power 100 50]\
[list -width {} {}]\
]
}
...
}</pre>
In this case, configuration is forced on the <i>fuel</i> and <i>power</i>
options, that is the corresponding set-<i>option</i> procedures will be
invoked when the switched object is constructed (see set-<i>option</i>
procedures documentation below).
<p>For the <i>fuel</i> option, since there is no initial value, the set-<i>fuel</i>
procedure is called with the default value (<i>petrol</i>) as argument.
For the <i>power</i> option, since the initial value differs from the default
value, the set-<i>power</i> procedure is called with the initial value
as argument (<i>50</i>).
<p>For the other options, since the initial values (last elements of the
option lists) are identical to their default values, the corresponding
set-<i>option</i> procedures will not be invoked. It is the programmer's
responsibility to insure that the initial option values are correct.
<p>The <b>set-<i>option</i></b> procedures may be viewed as dynamic virtual
functions. There must be one implementation per supported option, as returned
by the <i>options</i> procedure. For example:
<pre>class car {
...
proc options {this} {
return [list\
...
[list -width {} {}]\
]
}
...
proc set-width {this value} {
...
}
...
}</pre>
Since the <i>-width</i> option was listed in the options procedure, a <i>set-width</i>
procedure implementation is provided, which of course would proceed to
set the width of the car (and would modify the looks of a graphical representation,
for example).
<p>As you add a supported <i>option</i> in the list returned by the options
procedure, the corresponding set-<i>option</i> procedure may be called
as soon as the switched object is complete, which occurs when the switched
level <i>complete</i> procedure is invoked. For example:
<br>
<pre>class car {
proc car {this args} switched {args} {
...
switched::complete $this
}
...
proc options {this} {
return [list\
[list -fuel petrol]\
[list -length 4.5]\
[list -power 350]\
[list -width 1.8]\
]
}
proc set-fuel {this value} {
...
}
proc set-length {this value} {
...
}
proc set-power {this value} {
...
}
proc set-width {this value} {
...
}
}</pre>
<pre>new car</pre>
In this case, a new car is created with no options, which causes the car
constructor to be called, which in turns calls the switched level <i>complete</i>
procedure after the car object layer is completely initialized. At this
point, since there are no initial values in any option list in the options
procedure, the set-fuel procedure is called with its default value of <i>petrol</i>
as parameter, followed by the set-length call with <i>4.5</i> value, set-power
with <i>350</i> value and finally with set-width with <i>1.8</i> as parameter.
This is a good way to test the set-option procedures when debugging, and
when done, just fill-in the initial option values.
<p>The switched layer checks that an option is valid (that is, listed in
the options procedure) but obviously does not check the validity of the
value passed to the set-<i>option</i> procedure, which should throw an
error (for example by using the Tcl error command) if the value is invalid.
<p>The switched layer also keeps track of the options current values, so
that a set-<i>option</i> procedure is called only when the corresponding
option value passed as parameter is different from the current value (see
<i>-option</i>
data members description).
<p>The <b><i>-option</i></b> data member is the option current value. There
is one for each option listed in the options procedure. It is a read-only
value which the switched layer checks against when an option is changed.
It is rarely used at the layer derived from switched, except in the few
cases, such as in the following example:
<pre>...</pre>
<pre>proc car::options {this} {
return {
...
{-manufacturer {} {}}
...
}
}</pre>
<pre>proc car::set-manufacturer {this value} {}</pre>
<pre>proc car::printData {this} {
puts "manufacturer: $switched::($this,-manufacturer)"
...
}</pre>
In this case, the manufacturer's name is stored at the switched layer level
(this is why the set-manufacturer procedure has nothing to do) and later
retrieved in the printData procedure.
<p>The <b>complete</b> data member (not to be confused with the complete
procedure) is a boolean. Its initial value is <i>false</i> and it is set
to <i>true</i> at the very end of the switched complete procedure. It becomes
useful when some options should be set at construction time only and not
dynamically, as the following example shows:
<pre>proc car::set-width {this value} {
if {$switched::($this,complete)} {
error {option -width cannot be set dynamically}
}
...
}</pre>
</body>
</html>
|
