oo::class - class of all classes

oo::object
          → oo::class
________________________________________________________________________________________________________________

       Classes  are  objects  that  can  manufacture  other objects according to a pattern stored in the factory
       object (the class). An instance of the class is created by calling one of the  class's  factory  methods,
       typically  either  create if an explicit name is being given, or new if an arbitrary unique name is to be
       automatically selected.

       The oo::class class is the class of all classes; every class is an  instance  of  this  class,  which  is
       consequently  an  instance  of  itself. This class is a subclass of oo::object, so every class is also an
       object.  Additional metaclasses (i.e., classes of classes) can be defined  if  necessary  by  subclassing
       oo::class. Note that the oo::class object hides the new method on itself, so new classes should always be
       made using the create method.

   CONSTRUCTOR
       The  constructor  of  the  oo::class  class  takes an optional argument which, if present, is sent to the
       oo::define command (along with the name of the newly-created class) to allow the class to be conveniently
       configured at creation time.

   DESTRUCTOR
       The oo::class class does not define an explicit destructor. However, when a class is destroyed,  all  its
       subclasses and instances are also destroyed, along with all objects that it has been mixed into.

   EXPORTEDMETHODSclscreatename ?arg...?
              This  creates  a  new  instance of the class cls called name (which is resolved within the calling
              context's namespace if not fully qualified), passing the arguments, arg..., to  the  constructor,
              and (if that returns a successful result) returning the fully qualified name of the created object
              (the  result  of  the  constructor  is  ignored). If the constructor fails (i.e.  returns a non-OK
              result) then the object is destroyed and the error message is the result of this method call.

       clsnew ?arg...?
              This creates a new instance of the class cls with a new unique name, passing  the  arguments,  arg...,  to  the constructor, and (if that returns a successful result) returning the fully qualified
              name of the created object (the result of the constructor is ignored). If  the  constructor  fails
              (i.e.,  returns  a non-OK result) then the object is destroyed and the error message is the result
              of this method call.

              Note that this method is not exported by the oo::class object itself, so  classes  should  not  be
              created using this method.

   NON-EXPORTEDMETHODS
       The oo::class class supports the following non-exported methods:

       clscreateWithNamespacenamensName ?arg...?
              This  creates  a  new  instance of the class cls called name (which is resolved within the calling
              context's namespace if not fully qualified), passing the arguments, arg..., to  the  constructor,
              and (if that returns a successful result) returning the fully qualified name of the created object
              (the  result of the constructor is ignored). The name of the instance's internal namespace will be
              nsName; it is an error if that namespace cannot be  created.   If  the  constructor  fails  (i.e., 2
              returns  a non-OK result) then the object is destroyed and the error message is the result of this
              method call.

       This example defines a simple class hierarchy and creates a new instance of it. It then invokes a  method
       of the object before destroying the hierarchy and showing that the destruction is transitive.

              oo::classcreate fruit {
                  method eat {} {
                      puts "yummy!"
                  }
              }
              oo::classcreate banana {
                  superclass fruit
                  constructor {} {
                      my variable peeled
                      set peeled 0
                  }
                  method peel {} {
                      my variable peeled
                      set peeled 1
                      puts "skin now off"
                  }
                  method edible? {} {
                      my variable peeled
                      return $peeled
                  }
                  method eat {} {
                      if {![my edible?]} {
                          my peel
                      }
                      next
                  }
              }
              set b [banana new]
              $b eat               →prints"skinnowoff"and"yummy!"
              fruit destroy
              $b eat               →error"unknowncommand"

       class, metaclass, object

TclOO                                                  0.1                                           class(3tcl)

       oo::class - class of all classes

       oo::define(3tcl), oo::object(3tcl)

       package require tcl::oo

       oo::classmethod ?arg...?