This page describes how to migrate between [XOTcl] and [TclOO].
The direction is not important because there are good arguments to use both object-oriented frameworks like supported tcl versions, speed or availability in tcl core.

By programming [xotcl-light] I have fronted some discrepancies in function or even quite different meaning.
Although TclOO seems to be quite influenced by XOTcl, it was changed.

If you want to run [XOTcl] code without [XOTcl] extension try [xotcl-light]

**next command**

   * XOTcl supports '''next''' command without arguments, which is shortcut for just passing all arguments
   * In XOTcl '''next''' will be just ignored if there is no parent implementation; in TclOO it will lead to error message (unknown command)

**name and namespace**

TclOO distinguishes between name and namespace. For XOTcl, it is the same, but XOTcl will not create the namespace at once (for performance reasons); you need to call '''requireNamespace'''.

In TclOO you need to be careful about it. It could be that name and namespace are the same but not always. For objects created per '''new''' name and namespace are same.
By objects created per '''create''' they are different.


======
oo::class create A {
   method getName {} {
       self object
   }
}

set o1 [A new]
set o2 [A create mya]

info object namespace $o1
$o1 getName
info object namespace $o2
$o2 getName # we get ::mya
======

creating namespace for XOTcl object

======
$obj requireNamespace
======


**nesting objects**

XOTcl supports so-called nested objects. It is very useful to manage object lifetime (! there is no garbage collection in both oo extensions)

======
Class create A
set a [A new]
set child [A new -childof $a]
$a info children
$child info parent
$a destroy
# $child is also destroyed
======

In TclOO this can be simulated by using unexported method
cls createWithNamespace name nsName ?arg ...?

======
oo::class create A {
    self method createChildOf {object name args} {
        set ns [info object namespace $object]::$name
        my createWithNamespace $ns $ns {*}$args
    }
}
set a [A new]
set child [A createChildOf $a child]
$a destroy
======

**instvar and variable**

This method holds the instance variable into method context. The TclOO '''variable''' accepts only one argument.

**XOTcl parameters**

XOTcl support shortcuts for parameter

======
Class A -parameter p
set a [A new -p v1]
$a p
$a p 23
======


This can be easy simulated in TclOO by using some generic getter and setter and forward. 
passing '''-{name}''' is constructor to '''{name}''' method is some trick but maybe not the best XOTcl idea, because some other problems with it.

======
oo::class create A {
    method parHandler {parName args} {
        my variable $parName
        set $parName {*}$args
    }
    method createParameter par {
        oo::objdefine [self] forward $par [self] parHandler $par
    }
}
set a [A new]
$a createParameter p
$a p 2
$a p
======

**getting full object name**

In XOTcl you may always call the method without any argument on object name to get its full name (it is same as [self] call);
in TclOO you may need to use namespace command or '''self object''' (which can be abbreviated to '''self''').

XOTcl
======
Class A
namespace eval myns {
    A create mya
    set fullName [mya]
}

======

TclOO
======
oo::class create A {
   method getName {} {
       self
   }
}
namespace eval myns {
    A create mya
    set fullName [mya getName]
    # or standard tcl way
    set fullName [namespace which mya]
}
======

**XOTcl -volatile**

XOTcl has quite useful option that allows to limit the lifetime of object to scope of procedure, in which the object was created.
It is similar to ITcl itcl::local

XOTcl
======
Class A
proc foo {} {
   set a [A new -volatile]
   # object will be destroyed after the end of procedure
}
foo
======

In TclOO this functionality can be simulated by using the variable unset trace.
See implementation in [xotcl-light] or the implementation of itcl::local in Tcl 8.6.


<<categories>> XOTcl | TclOO | Object Orientation