Star Methods
+Design study for implementing methods which applies to instances of +instances meta-classes. This study implements in addition to the +regular "method" a new construct called "*method" which has the +mentioned transitive property. The same behavior can be achieved in +many ways. In this study, we define a special class (the method +container class for *methods) which is kept in the precedence path +of instances. This way, it can be defined freely with other +extension mechanisms such as mixins, traits or filters.
nx::Class eval { + # + # Define a *method, which is a method that applies for instances of + # the instances of a meta-class. + # - *methods are only defineable on meta-classes + # - *methods are applicable on the instances of the instances of the + # meta-class + # - If one defines a *method "bar" on a meta-class "MClass", and a + # class "C" as an instance of "MClass", and "c1" is an instance of + # "C", then "bar" is applicable for "c1". + + # + # The "*method" has the same signature as regular methods, and can + # be used in combination with the modifiers + # public/protected/private as usual. + # + :public method *method {name arguments:parameter,0..* -returns body -precondition -postcondition} { + # + # Allow the definition only on meta-classes + # + if {![nsf::is metaclass [self]]} { + error "[self] is not a meta-class" + } + # + # Do we have the class for keeping the *methods already? + # + set starClass [nx::Class create [self]::*] + + if {![nsf::object::exists $starClass]} { + # + # If not, create the *method container class and provide + # it as a default in the superclass hierarchy. This + # happens by modifying the property "-superclasses" which + # is used on every class to specify the class hierarchy. + # + :property [list superclasses $starClass] { + # + # Define a slot-specific method for keeping the + # *method container class in the hierarchy. + # + :public object method appendToRelations { class property value } { + set sc [nsf::relation::get $class $property] + if {$sc eq "::nx::Object"} { + nsf::relation::set $class $property $value + } else { + nsf::relation::set $class $property [concat $sc $value] + } + } + + # + # Whenever the "-superclasses" relation is called, + # make sure, we keep the *method container class in + # the hierarchy. + # + :public object method value=set { class property value } { + :appendToRelations $class superclass $value + } + } + + # + # Update class hierarchies of the previously created instances + # of the meta-class. + # + foreach class [:info instances] { + set slot [$class info lookup slots superclasses] + $slot appendToRelations $class superclass $starClass + } + } + + # + # Define the *method as regular method in the star method + # container class. + # + [self]::* method $name $arguments \ + {*}[expr {[info exists returns] ? [list -returns $returns] : ""}] \ + $body \ + {*}[expr {[info exists precondition] ? [list -precondition $precondition] : ""}] \ + {*}[expr {[info exists postcondition] ? [list -postcondition $postcondition] : ""}] + } +} +set ::nsf::methodDefiningMethod(*method) 1
Some base test cases:
+Define a meta-class MClass with a method "foo" and to star methods +named "foo" and "bar".
nx::Class create MClass -superclass nx::Class { + :public method foo {} {return MClass-[next]} + :public *method foo {} {return *-[next]} + :public *method bar {} {return *-[next]} +}
Define a class based on MClass and define here as well a method +"foo" to show the next-path in combination with the *methods.
MClass create C { + :public method foo {} {return C-[next]} +} + +% C info superclasses +::MClass::*
Finally create an instance with the method foo as well.
C create c1 { + :public object method foo {} {return c1-[next]} +}
The result of "foo" reflects the execution order: object before +classes (including the *method container).
% c1 info precedence
+::C ::MClass::* ::nx::Object
+% c1 foo
+c1-C-*-
+% c1 bar
+*-Define a Class D as a specialization of C
MClass create D -superclass C { + :public method foo {} {return D-[next]} + :create d1 +} + +% d1 info precedence +::D ::C ::MClass::* ::nx::Object +% d1 foo +D-C-*-
Dynamically add *method "baz".
% d1 baz +::d1: unable to dispatch method 'baz' +MClass eval { + :public *method baz {} {return baz*-[next]} +} +% d1 baz +baz*-
Test adding of *methods at a time, when the meta-class has already +instances.
Create a meta-class without a *method
nx::Class create MClass2 -superclass nx::Class +MClass2 create X {:create x1} +% x1 info precedence +::X ::nx::Object
Now add a *method
MClass2 eval { + :public *method baz {} {return baz*-[next]} +}
Adding the *method alters the superclass order of already created +instances of the meta-class
% x1 info precedence
+::X ::MClass2::* ::nx::Object
+% x1 baz
+baz*-Finally, there is a simple application example for ActiveRecord +pattern. All instances of the application classes (such as +"Product") should have a method "save" (together with other methods +now shown here). First define the ActiveRecord class (as a +meta-class).
Class create ActiveRecord -superclass nx::Class { + :property table_name + + :method init {} { + if {![info exists :table_name]} { + set :table_name [string tolower [namespace tail [self]]s] + } + } + :public *method save {} { + puts "save [self] into table [[:info class] cget -table_name]" + } +}
Define the application class "Product" with an instance
ActiveRecord create Product +Product create p1 +p1 save
The last command prints out: "save ::p1 into table products"