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"