my(n) TclOO Commands my(n)

```

```

# [NAME](#NAME)

my, myclass - Invoke any method of current object or its class

# [SYNOPSIS](#SYNOPSIS)

```
package require tcl::oo
my methodName ?arg ...?
myclass methodName ?arg ...?
```

```

```

# [DESCRIPTION](#DESCRIPTION)

The **my** command is used to allow methods of objects to invoke methods of the object (or its class), and the **myclass** command is used to allow methods of objects to invoke methods of the current class of the object *as an object*. In particular, the set of valid values for *methodName* is the set of all methods supported by an object and its superclasses, including those that are not exported and private methods of the object or class when used within another method defined by that object or class.

The object upon which the method is invoked via **my** is the one that owns the namespace that the **my** command is contained in initially (**NB:** the link remains if the command is renamed), which is the currently invoked object by default. Similarly, the object on which the method is invoked via **myclass** is the object that is the current class of the object that owns the namespace that the **myclass** command is contained in initially. As with **my**, the link remains even if the command is renamed into another namespace, and defaults to being the manufacturing class of the current object.

Each object has its own **my** and **myclass** commands, contained in its instance namespace.

# [EXAMPLES](#EXAMPLES)

This example shows basic use of **my** to use the **variables** method of the **oo::object** class, which is not publicly visible by default:

```
oo::class create c {


    method count {} {


        my variable counter


        puts [incr counter]


    }
}
c create o
o count              → prints "1"
o count              → prints "2"
o count              → prints "3"
```

This example shows how you can use **my** to make callbacks to private methods from outside the object (from a **trace**), using **namespace code** to enter the correct context. (See the **callback** command for the recommended way of doing this.)

```
oo::class create HasCallback {


    method makeCallback {} {


        return [namespace code {


            my Callback


        }]


    }


    method Callback {args} {


        puts "callback: $args"


    }
}
set o [HasCallback new]
trace add variable xyz write [$o makeCallback]
set xyz "called"     → prints "callback: xyz {} write"
```

This example shows how to access a private method of a class from an instance of that class. (See the **classmethod** declaration in **oo::define** for a higher level interface for doing this.)

```
oo::class create CountedSteps {


    self {


        variable count


        method Count {} {


            return [incr count]


        }


    }


    method advanceTwice {} {


        puts "in [self] step A: [myclass Count]"


        puts "in [self] step B: [myclass Count]"


    }
}
CountedSteps create x
CountedSteps create y
x advanceTwice       → prints "in ::x step A: 1"


                     → prints "in ::x step B: 2"
y advanceTwice       → prints "in ::y step A: 3"


                     → prints "in ::y step B: 4"
x advanceTwice       → prints "in ::x step A: 5"


                     → prints "in ::x step B: 6"
y advanceTwice       → prints "in ::y step A: 7"


                     → prints "in ::y step B: 8"
```

# [SEE ALSO](#SEE_ALSO)

[next(n)](/man/os/tcl/next.n), [oo::object(n)](/man/os/tcl/oo::object.n), [self(n)](/man/os/tcl/self.n)

# [KEYWORDS](#KEYWORDS)

method, method visibility, object, private method, public method

0.1 TclOO

---

Document: myclass(n) from tcl 9.1.0-r0 (Chainguard OS)
Source: https://downloads.sourceforge.net/project/tcl/Tcl/9.1.0/tcl9.1.0-src.tar.gz