NAME

       body - change the body for a class method/proc


SYNOPSIS

       body className::function args body
_________________________________________________________________


DESCRIPTION

       The  body  command  is used outside of an [incr Tcl] class
       definition to define or  redefine  the  body  of  a  class
       method  or  proc.  This facility allows a class definition
       to have separate "interface" and  "implementation"  parts.
       The  "interface" part is a class command with declarations
       for methods, procs, instance variables  and  common  vari­
       ables.   The "implementation" part is a series of body and
       configbody commands.  If the "implementation" part is kept
       in  a  separate file, it can be sourced again and again as
       bugs are fixed, to support interactive development.   When
       using  the "tcl" mode in the emacs editor, the "interface"
       and "implementation" parts can be kept in the  same  file;
       as  bugs  are  fixed, individual bodies can be highlighted
       and sent to the test application.

       The name "className::function" identifies the  method/proc
       being changed.

       If  an  args  list  was  specified  when  the function was
       defined in the class definition, the  args  list  for  the
       body  command  must  match in meaning.  Variable names can
       change, but the argument lists must have the same required
       arguments  and  the same default values for optional argu­
       ments.  The special args argument acts as a wildcard  when
       included in the args list in the class definition; it will
       match zero or more arguments of any type when the body  is
       redefined.

       If  the  body string starts with "@", it is treated as the
       symbolic name for a C procedure.  The args list has little
       meaning  for  the  C  procedure,  except  to  document the
       expected usage.  (The C procedure is not guaranteed to use
       arguments  in  this  manner.)  If body does not start with
       "@", it is treated as a  Tcl  command  script.   When  the
       function  is  invoked,  command line arguments are matched
       against the args list, and local variables are created  to
       represent each argument.  This is the usual behavior for a
       Tcl-style proc.

       Symbolic names for C procedures are established by  regis­
       tering  procedures  via Itcl_RegisterC().  This is usually
       done in the Tcl_AppInit() procedure,  which  is  automati­
       cally  called  when  the  interpreter  starts  up.  In the

       with  the symbolic name "foo".  This procedure can be ref­
       erenced in the body command as "@foo".
              int
              Tcl_AppInit(interp)
                  Tcl_Interp *interp;     /* Interpreter for application. */
              {
                  if (Itcl_Init(interp) == TCL_ERROR) {
                      return TCL_ERROR;
                  }

                  if (Itcl_RegisterC(interp, "foo", My_FooCmd) != TCL_OK) {
                      return TCL_ERROR;
                  }
              }


EXAMPLE

       In the following example, a "File"  class  is  defined  to
       represent  open  files.   The  method  bodies are included
       below the class definition via  the  body  command.   Note
       that  the  bodies  of  the  constructor/destructor must be
       included in the class definition, but they  can  be  rede­
       fined via the body command as well.
              class File {
                  private variable fid ""
                  constructor {name access} {
                      set fid [open $name $access]
                  }
                  destructor {
                      close $fid
                  }

                  method get {}
                  method put {line}
                  method eof {}
              }

              body File::get {} {
                  return [gets $fid]
              }
              body File::put {line} {
                  puts $fid $line
              }
              body File::eof {} {
                  return [::eof $fid]
              }

              #
              # See the File class in action:
              #
              File x /etc/passwd "r"
              while {![x eof]} {
                  puts "=> [x get]"

              delete object x


KEYWORDS

       class, object, procedure


Man(1) output converted with man2html