Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
self(n)				TclOO Commands			       self(n)

NAME
       self - method call internal introspection

SYNOPSIS
       package require TclOO

       self ?subcommand?

DESCRIPTION
       The  self command, which	should only be used from within	the context of
       a call to a method (i.e.	inside a  method,  constructor	or  destructor
       body)  is used to allow the method to discover information about	how it
       was called. It takes an argument, subcommand, that tells	it  what  sort
       of  information	is actually desired; if	omitted	the result will	be the
       same as if self object was invoked. The supported subcommands are:

       self call
	      This returns a two-element list describing the method  implemen-
	      tations used to implement	the current call chain.	The first ele-
	      ment is the same as would	be reported by info  object  call  for
	      the  current method (except that this also reports useful	values
	      from within constructors and destructors), and the  second  ele-
	      ment  is	an  index into the first element's list	that indicates
	      which actual implementation is currently	executing  (the	 first
	      implementation to	execute	is always at index 0).

       self caller
	      When  the	 method	was invoked from inside	another	object method,
	      this subcommand returns a	three element list describing the con-
	      taining  object  and  method.  The  first	 element describes the
	      declaring	object or class	of the method, the second  element  is
	      the  name	 of  the  object  on  which  the containing method was
	      invoked, and the third element is	the name of the	 method	 (with
	      the  strings <constructor> and <destructor> indicating construc-
	      tors and destructors respectively).

       self class
	      This returns the name of the class that the current  method  was
	      defined  within.	 Note  that  this  will	change as the chain of
	      method implementations is	traversed with next, and that  if  the
	      method was defined on an object then this	will fail.

	      If  you  want  the  class	of the current object, you need	to use
	      this other construct:

	      info object class	[self object]

       self filter
	      When invoked inside a filter, this subcommand  returns  a	 three
	      element  list describing the filter. The first element gives the
	      name of the object or class that declared	the filter (note  that
	      this may be different from the object or class that provided the
	      implementation of	the filter),  the  second  element  is	either
	      object or	class depending	on whether the declaring entity	was an
	      object or	class, and the third element is	the name of  the  fil-
	      ter.

       self method
	      This  returns  the  name of the current method (with the strings
	      <constructor>  and  <destructor>	indicating  constructors   and
	      destructors respectively).

       self namespace
	      This returns the name of the unique namespace of the object that
	      the method was invoked upon.

       self next
	      When invoked from	a method that is not at	 the  end  of  a  call
	      chain  (i.e. where the next command will invoke an actual	method
	      implementation), this subcommand	returns	 a  two	 element  list
	      describing  the next element in the method call chain; the first
	      element is the name of the class or  object  that	 declares  the
	      next  part of the	call chain, and	the second element is the name
	      of the method (with the strings <constructor>  and  <destructor>
	      indicating   constructors	  and  destructors  respectively).  If
	      invoked from a method that is at the end of a call  chain,  this
	      subcommand returns the emtpy string.

       self object
	      This  returns the	name of	the object that	the method was invoked
	      upon.

       self target
	      When invoked inside a  filter  implementation,  this  subcommand
	      returns a	two element list describing the	method being filtered.
	      The first	element	will be	 the  name  of	the  declarer  of  the
	      method,  and  the	 second	element	will be	the actual name	of the
	      method.

EXAMPLES
       This example shows basic	use of self to provide information  about  the
       current object:

       oo::class create	c {
	   method foo {} {
	       puts "this is the [self]	object"
	   }  }	 c create a c create b a foo		    -_ prints "this is
       the ::a object" b foo		    -_ prints "this is the ::b object"

       This demonstrates what a	method call chain looks	like, and how travers-
       ing along it changes the	index into it:

       oo::class create	c {
	   method x {} {
	       puts "Cls: [self	call]"
	   } } c create	a oo::objdefine	a {
	   method x {} {
	       puts "Obj: [self	call]"
	       next
	       puts "Obj: [self	call]"
	   }  }	 a  x	   -_  Obj:  {{method  x  object method} {method x ::c
       method}}	0
	       -_ Cls: {{method	x object method} {method x ::c method}}	1
	       -_ Obj: {{method	x object method} {method x ::c method}}	0

SEE ALSO
       info(n),	next(n)

KEYWORDS
       call, introspection, object

TclOO				      0.1			       self(n)

NAME | SYNOPSIS | DESCRIPTION | EXAMPLES | SEE ALSO | KEYWORDS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=self&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help