Class

+---------+
| ::nx::* |
+---------+--------------------------------------Y
|                                                |
|  instance of                                   |
|   .-------.                                    |
|  +--------'+     instance of     +----------+  |
|  |         |<....................|          |  |
|  |  Class  |                     |  Object  |  |
|  |         |....................>|          |  |
|  +---------+     subclass of     +-----+----+  |
|   ^   ^                                ^       |
\...|...|................................|......./
    |   |                                |
    |   |subclass.....(xor)......subclass|
    |   |of       +-----------+        of|
    |   |.........|           |..........|
    | (metaclass) |   /cls/   | (application class)
    |.............|           |
    instance of   +-----------+

cls ?public | private | protected? alias ?-debug? ?-deprecated? methodName ? -returns valueChecker? ?-frame object | method? cmdName

Define an alias method for the given class. The resulting method registers a pre-existing Tcl command cmdName under the (alias) name methodName with the class. If cmdName refers to another method, the corresponding argument should be a valid method handle. If a Tcl command (e.g., a proc), the argument should be a fully qualified Tcl command name. If aliasing a subcommand (e.g., array exists) of a Tcl namespace ensemble (e.g., array), cmdName must hold the fully qualified subcommand name (and not the ensemble name of the subcommand). As for a regular class method, -returns allows for setting a value checker on the values returned by the aliased command cmdName. When creating an alias method for a C-implemented Tcl command (i.e., command defined using the Tcl/NX C-API), -frame sets the scope for variable references used in the aliased command. If the provided value is object, then variable references will be resolved in the context of the called object, i.e., the object upon which the alias method is invoked, as if they were object variables. There is no need for using the colon-prefix notation for identifying object variables. If the value is method, then the aliased command will be executed as a regular method call. The command is aware of its called-object context; i.e., it can resolve ::nx::self. In addition, the alias method has access to the method-call context (e.g., nx::next). If -frame is omitted, and by default, the variable references will resolve in the context of the caller of the alias method. To express deprecation of the alias method methodName, set the -deprecated flag. Deprecated methods remain usable from client code, but their usage will be signaled to the developer and/or can be tracked using ::nsf::deprecated. To register methodName with the debugger, set the -debug flag. Entering and exiting a method, which was flagged for debugging, is recorded by calling the redefinable callback procs ::nsf::debug::call and ::nsf::debug::exit, respectively. By default, these callbacks forward to ::nsf::log, which can also be customized at the script level.

cls __class_configureparameter

Computes and returns the configuration options available for cls instances, to be consumed as method-parameter specification by configure.

cls create instanceName ?option value option value ...?

This factory method creates an instance instanceName of cls and returns instanceName.

% nx::Class create AClass {
    :method init args {
      next
    }; # initialization method for instances of 'AClass'
  }; # defines a class 'AClass' being an instance of 'nx::Class'
::AClass
% ::AClass create anInstance; # defines an object 'anInstance' being an instance of 'AClass'
::anInstance
% ::anInstance info class
::AClass
% ::AClass info class
::nx::Class

create accepts the configuration options option available for this instance, such as those defined by properties of cls (see property). Note that create is called internally when defining an instance of cls using new. By calling create on nx::Class itself, the created instance will become a new application class instanceName on which create can also be applied (i.e., it can be instantiated). If the so-created class has ::nx::Class its direct or indirect superclass, instanceName is referred to as a metaclass; that is, a class whose instances are again classes.

cls delete feature arg

This method serves as the equivalent to Tcl's rename for removing structural (properties, variables) and behavioral features (methods) of the class:

cls delete property propertyName

cls delete variable variableName

cls delete method methodName

Removes a property propertyName, variable variableName, and method methodName, respectively, previously defined for the scope of the class. delete method can be equally used for removing regular methods (see method), an alias method (see alias), and a forwarder method (see forward).

cls filters submethod ?arg ...?

Accesses and modifies the list of methods which are registered as filters with cls using a specific setter or getter submethod:

Every methodName in a spec must resolve to an existing method in the scope of the class. To access and to manipulate the list of filters of cls, cget|configure -filters can also be used.

cls ?public | protected | private? forward ?-debug? ?-deprecated? methodName ? -prefix prefixName? ?-frame object? ? -returns valueChecker? ?-verbose? ?target? ? arg ...?

Define a forward method for the given class. The definition of a forward method registers a predefined, but changeable list of forwarder arguments under the (forwarder) name methodName. Upon calling the forward method, the forwarder arguments are evaluated as a Tcl command call. That is, if present, target is interpreted as a Tcl command (e.g., a Tcl proc or an object) and the remainder of the forwarder arguments arg as arguments passed into this command. The actual method arguments to the invocation of the forward method itself are appended to the list of forwarder arguments. If target is omitted, the value of methodName is implicitly set and used as target. This way, when providing a fully-qualified Tcl command name as methodName without target, the unqualified methodName ( namespace tail) is used as the forwarder name; while the fully-qualified one serves as the target. As for a regular method, -returns allows for setting a value checker on the values returned by the resulting Tcl command call. When passing object to -frame, the resulting Tcl command is evaluated in the context of the object receiving the forward method call. This way, variable names used in the resulting execution of a command become resolved as object variables. To express deprecation of the forward method methodName, set the -deprecated flag. Deprecated methods remain usable from client code, but their usage will be signaled to the developer and/or can be tracked using ::nsf::deprecated. To register methodName with the debugger, set the -debug flag. Entering and exiting a method, which was flagged for debugging, is recorded by calling the redefinable callback procs ::nsf::debug::call and ::nsf::debug::exit, respectively. By default, these callbacks forward to ::nsf::log, which can also be customized at the script level. The list of forwarder arguments arg can contain as its elements a mix of literal values and placeholders. Placeholders are prefixed with a percent symbol (%) and substituted for concrete values upon calling the forward method. These placeholders allow for constructing and for manipulating the arguments to be passed into the resulting command call on the fly:

cls info heritage ?pattern?

If pattern is omitted, returns the list of object names of all the direct and indirect superclasses and per-class mixin classes of cls, in their order of precedence, which are active for instances of cls. If pattern is specified, only superclasses and mixin classes whose names match pattern will be listed (see string match).

cls info instances ?-closure? ?pattern?

If pattern is not specified, returns a list of the object names of all the direct instances of cls. If the switch -closure is set, indirect instances are also returned. A direct instance is created by using create or new on cls, an indirect instance was created from a direct or indirect subclass of cls. If pattern is specified, only instances whose names match pattern will be listed (see string match).

cls info mixinof ?-closure? ?-scope option? ?pattern?

If pattern is not specified, returns a list of the object names of all the objects for which cls is active as a direct mixin class. If the switch -closure is set, objects which have cls as an indirect mixin class are also returned. If pattern is specified, only objects whose names match pattern will be listed (see string match). Valid values of option are all, object, and class. Passing object will have only objects returned which have cls as per-object mixin class. Passing class will have only classes returned which have cls as per-class mixin class. all (the default) will have contained both in the returned list.

cls info subclasses ?-closure? ?-dependent? ? pattern?

If pattern is not specified, returns a list of the object names of the direct subclasses of cls. If the switch -closure is set, indirect subclasses are also returned. If the switch -dependent is on, indirect subclasses introduced by mixin class relations of subclasses of cls are also reported. -closure and -dependent are mutually exclusive. If pattern is specified, only subclasses whose names match pattern will be listed (see string match).

cls info superclasses ?-closure? ?pattern?

If pattern is not specified, returns a list of the object names of all direct superclasses of cls. If the switch -closure is set, indirect superclasses will also be returned. If pattern is specified, only superclasses whose names match pattern will be listed (see string match).

cls info info ?-asList?

Returns the available submethods of the info method ensemble for cls, either as a pretty-printed string or as a Tcl list (if the switch -asList is set) for further processing.

cls info filters ?-guards? ?pattern?

If pattern is omitted, returns all filter names which are defined by cls. By turning on the switch -guards, the corresponding guard expressions, if any, are also reported along with each filter as a three-element list: filterName -guard guardExpr. By specifying pattern, the returned filters can be limited to those whose names match patterns (see string match).

cls info method option methodName

This introspection submethod provides access to the details of methodName provided by cls. If methodName is not the name of an existing method, an empty string is returned. To disambiguate between a non-existing method and an empty string as valid return value (e.g., for info method args|parameters|args|...), use info method exists. Permitted values for option are:

cls info methods ?-callprotection level? ? -type methodType? ?-path? ?namePattern?

Returns the names of all methods defined by cls. Methods covered include those defined using alias and forward. The returned methods can be limited to those whose names match namePattern (see string match). By setting -callprotection, only methods of a certain call protection level (public, protected, or private) will be returned. Methods of a specific type can be requested using -type. The recognized values for methodType are:

cls info mixins ?-guards? ?pattern?

If pattern is omitted, returns the object names of the mixin classes which extend cls directly. By turning on the switch -guards, the corresponding guard expressions, if any, are also reported along with each mixin as a three-element list: className -guard guardExpr. The returned mixin classes can be limited to those whose names match patterns (see string match).

cls info slots ?-type className? ? pattern?

If pattern is not specified, returns the object names of all slot objects defined by cls. The returned slot objects can be limited according to any or a combination of the following criteria: First, slot objects can be filtered based on their command names matching pattern (see string match). Second, -type allows one to select slot objects which are instantiated from a subclass className of nx::Slot (default: nx::Slot).

cls info variables ?pattern?

If pattern is omitted, returns the object names of all slot objects provided by cls which are responsible for managing properties and variables of cls. Otherwise, only slot objects whose names match pattern are returned. This is equivalent to calling: cls info slots -type ::nx::VariableSlot pattern. To extract details of each slot object, use the info submethods available for each slot object.

cls ?public | protected | private? method ?-debug? ?-deprecated? name parameters ?-checkalways? ?-returns valueChecker? body

Defines a scripted method methodName for the scope of the class. The method becomes part of the class's signature interface. Besides a methodName, the method definition specifies the method parameters and a method body. parameters accepts a Tcl list containing an arbitrary number of non-positional and positional parameter definitions. Each parameter definition comprises a parameter name, a parameter-specific value checker, and parameter options. The body contains the method implementation as a script block. In this body script, the colon-prefix notation is available to denote an object variable and a self call. In addition, the context of the object receiving the method call (i.e., the message) can be accessed (e.g., using nx::self) and the call stack can be introspected (e.g., using nx::current). Optionally, -returns allows for setting a value checker on values returned by the method implementation. By setting the switch -checkalways, value checking on arguments and return value is guaranteed to be performed, even if value checking is temporarily disabled; see nx::configure). To express deprecation of the method name, set the -deprecated flag. Deprecated methods remain usable from client code, but their usage will be signaled to the developer and/or can be tracked using ::nsf::deprecated. To register name with the debugger, set the -debug flag. Entering and exiting a method, which was flagged for debugging, is recorded by calling the redefinable callback procs ::nsf::debug::call and ::nsf::debug::exit, respectively. By default, these callbacks forward to ::nsf::log, which can also be customized at the script level. A method closely resembles a Tcl proc, but it differs in some important aspects: First, a method can define non-positional parameters and value checkers on arguments. Second, the script implementing the method body can contain object-specific notation and commands (see above). Third, method calls cannot be intercepted using Tcl trace. Note that an existing Tcl proc can be registered as an alias method with the class (see alias).

cls mixins submethod ?arg ...?

Accesses and modifies the list of mixin classes of cls using a specific setter or getter submethod:

At the time of setting the mixin relation, that is, calling mixins, every className as part of a spec must be an existing instance of nx::Class. To access and to manipulate the list of mixin classes of cls, cget|configure -mixins can also be used.

cls new ?-childof parentName? ?option value option value ...?

A factory method to create autonamed instances of cls. It returns the name of the newly created instance. For example:

% nx::Class create AClass; # defines a class 'AClass' being an instance of 'nx::Class'
::AClass
% set inst [::AClass new]; # defines an autonamed object being an instance of 'AClass'
::nsf::__#0
% $inst info class
::AClass

The factory method will provide computed object names of the form, e.g. ::nsf::__#0. The uniqueness of generated object names is guaranteed for the scope of the current Tcl interpreter only. It is a frontend to create which will be called by new once the name of the instance has been computed, passing along the arguments option to new as the configuration options (see create). If -childof is provided, the new object will be created as a nested object of parentName. parentName can be the name of either an existing NX object or an existing Tcl namespace. If non-existing, a Tcl namespace parentName will be created on the fly.

cls property ?-accessor public | protected | private? ?-class className? ?-configurable trueFalse? ?-incremental? ?-trace set | get | default? spec ?initBlock?

Defines a property for the scope of the class. The spec provides the property specification as a list holding at least one element or, maximum, two elements: propertyName?: typeSpec? ?defaultValue?. The propertyName is also used as to form the names of the getter/setter methods, if requested (see -accessor). It is, optionally, equipped with a typeSpec following a colon delimiter which specifies a value checker for the values which become assigned to the property. The second, optional element sets a defaultValue for this property. If -accessor is set, a property will provide for different getter and setter methods:

The option value passed along -accessor sets the level of call protection for the generated getter and setter methods: public, protected, or private. By default, no getter and setter methods are created. Turning on the switch -incremental provides a refined setter interface to the value managed by the property. First, setting -incremental implies requesting -accessor (set to public by default, if not specified explicitly). Second, the managed value will be considered a valid Tcl list. A multiplicity of 1..* is set by default, if not specified explicitly as part of spec. Third, to manage this list value element-wise ( incrementally), two additional setter methods become available:

Assuming default settings, every property is realized by a slot object. Provided a slot object managing the property is to be created, a custom class className from which this slot object is to be instantiated can be set using -class. The default value is ::nx::VariableSlot. The last argument initBlock accepts an optional Tcl script which is passed into the initialization procedure (see configure) of the property's slot object. See also initBlock for create and new.

cls require ?public | protected | private? method methodName

Attempts to register a method definition made available using ::nsf::method::provide under the name methodName with cls . The registered method is subjected to default call protection ( protected), if not set explicitly.

cls variable ?-accessor public | protected | private? ?-incremental? ?-class className? ?-configurable trueFalse? ?-initblock ? -trace set | get | default? script? spec ? defaultValue?

Defines a variable for the scope of the class. The spec provides the variable specification: variableName?: typeSpec?. The variableName will be used to name the underlying Tcl variable and the getter/setter methods, if requested (see -accessor). spec is optionally equipped with a typeSpec following a colon delimiter which specifies a value checker for the values managed by the variable. Optionally, a defaultValue can be defined. If -accessor is set explicitly, a variable will provide for getter and setter methods:

The option value passed along -accessor sets the level of call protection for the getter and setter methods: public, protected, or private. By default, no getter and setter methods are created. Turning on the switch -incremental provides a refined setter interface to the value managed by the variable. First, setting -incremental implies requesting -accessor ( public by default, if not specified explicitly). Second, the managed value will be considered a valid Tcl list. A multiplicity of 1..* is set by default, if not specified explicitly as part of spec (see above). Third, to manage this list value element-wise ( incrementally), two additional setter operations become available:

Provided a slot object managing the variable is to be created, a custom class className from which this slot object is to be instantiated can be set using -class. The default value is ::nx::VariableSlot. Using -initblock, an optional Tcl script can be defined which becomes passed into the initialization procedure (see configure) of the variable's slot object. See also initBlock for create and new.

        /cls/->create(/instance/)
                  .---------------.   exists?    [false]   .----------------.                   .-------------------.
             ---->|Class::create()|----><>---------------->|Class::__alloc()|-----------><>---->|Object::configure()|
                  `---------------'      |      (1)        `----------------'             ^ (3) `---------+---------'
                                  [true] |                                                |               | (4)
                                         |  .-------------------.                         |      .------------------.
                                         `->|Class::__recreate()|-------------------------'      |/instance/->init()|
                                      (2)   `-------------------'                                `------------------'
    /instance/->destroy()
        .-----------------.     .------------------.
   ---->|Object::destroy()|---->|Class::__dealloc()|
        `-----------------' (5) `------------------'

% nx::Class create Foo {:property x}
% Foo method init {} {set :y [expr {${:x} + 1}]}
% Foo public method bar {} {return ${:y}}
% Foo create f1 -x 101
% f1 cget -x
101
% f1 bar
102

% Object create Bar
::Bar
% Object create Bar; # calls Object->__recreate(::Bar, ...)
::Bar

•

An existing class is requested to be recreated as an object.

•

An existing object is requested to be recreated as a class.

  % Object create Bar
  ::Bar
  % Class create Bar; # calls Bar->destroy() & Class::create(::Bar, ...)

•

An object of an object system other than NX (e.g. XOTcl2) is asked to be recreated.