NAME

       oo::class - class of all classes

SYNOPSIS

       package require TclOO

       oo::class method ?arg ...?

CLASS HIERARCHY

       oo::object
          → oo::class
_________________________________________________________________________________________________

DESCRIPTION

       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.

   EXPORTED METHODS
       cls create name ?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.

       cls new ?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-EXPORTED METHODS
       The oo::class class supports the following non-exported methods:

       cls createWithNamespace name nsName ?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 unless that
              namespace already exists (when an arbitrary name will be chosen  instead).  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.

EXAMPLES

       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::class create fruit {
                  method eat {} {
                      puts "yummy!"
                  }
              }
              oo::class create 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 "skin now off" and "yummy!"
              fruit destroy
              $b eat               → error "unknown command"

SEE ALSO

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

KEYWORDS

       class, metaclass, object