How does one access a derived classes member variables from within the superclass in Tcl? - oop

Question

Code:
package require TclOO
oo::class create Supe {
variable cape boots
constructor {} {
puts -nonewline "Supe: "
puts [info class variables [self class]]
}
}
oo::class create Clark {
superclass Supe
variable glasses suit
constructor {} {
puts -nonewline "Clark: "
puts [info class variables [self class]]
next
}
}
set hero [Clark new]
Output:
Clark: glasses suit
Supe: cape boots
Is it possible to get a list of Clark's member variables from within Supe's constructor without passing them into Supe as an argument?
Ultimately, the goal is to dynamically set derived class variables from a dict argument:
foreach {varName} [info class variables [self class]] {
variable $varName [dict get $args $varName]
}
If the above code can be used in the superclass constructor, it would avoid putting it in each derived class constructor.

Answer 1

You can get the name of the object with self object, or just self. You can then get the class of the object with info object class. And finally, you can get the member variables of a class with info class variables.
Putting it all together results in:
[info class variables [info object class [self]]]

Answer 2

My take does not add to the answer already given, but looks at the motivating problem of the OP:
Ultimately, the goal is to dynamically set derived class variables
from a dict argument:
What I have been using in the past to batch-update an object's state is sth. along the lines of:
oo::class create C {
variable a b
constructor {aDict} {
my variable {*}[lsort -unique [my lookupVars [info object class [self]]]]
# dict with aDict {;}
lassign [dict values $aDict] {*}[dict keys $aDict]
}
method lookupVars {currentClass} {
set v [info class variables $currentClass]
foreach scl [info class superclasses $currentClass] {
if {$scl eq "::oo::object"} {
break
}
lappend v {*}[my lookupVars $scl]
}
return $v
}
method print {} {
foreach v [info object vars [self]] {
my variable $v
puts "<$v> [set $v]"
}
}
}
The key items are:
lookupVars is a naturally recursive implementation walking the class, direct, and indirect superclasses to collect of defined per-class variables. This follows up on what Donal describes as a discovery of "properties". Note that this is limited in several ways (e.g., mixins are ignored, also TclOO's internal linearisation scheme is not reflected, no control for duplicates etc.)
lassign can be used to set multiple variables at once. Alternatively, but with some side effects, dict with "loads" a given dict's content into variables available for the current scope. my variable ?varName ...? will provide method-local links to the collected per-class variables. This way, you save a script-level loop and don't have to filter the provided dict for unmatched keys.
Watch:
oo::class create D {
superclass C
variable c d
}
oo::class create E {
superclass D
variable e f
}
[D new {a 1 b 2 c 3 d 4}] print
[E new {a 1 b 2 c 3 d 4 f 5 e 8 x 3}] print
[D new {a 1 b 2 c 3 d 4 f 5 x 3}] print