Package org.python.core

## Interface Traverseproc

- All Known Implementing Classes:
    `_marshal.Marshaller`, `_marshal.Unmarshaller`, `AbstractMemoryCData`, `AbstractReference`, `ArrayCData`, `ArrayCData.ArrayIter`, `AstList`, `BaseDictionaryView`, `BaseSet`, `CallableProxyType`, `CData`, `chain`, `chainDerived`, `combinations`, `combinationsDerived`, `combinationsWithReplacement`, `combinationsWithReplacementDerived`, `compress`, `compressDerived`, `Condition`, `count`, `countDerived`, `cStringIO.StringIO`, `cycle`, `cycleDerived`, `dict_builder`, `dropwhile`, `dropwhileDerived`, `Encoder`, `EncoderDerived`, `Fetch`, `FieldNameIterator`, `Function`, `groupby`, `groupbyDerived`, `ifilter`, `ifilterDerived`, `ifilterfalse`, `ifilterfalseDerived`, `imap`, `imapDerived`, `islice`, `isliceDerived`, `izip`, `izipDerived`, `izipLongest`, `izipLongestDerived`, `JavaIterator`, `MatchObject`, `PatternObject`, `permutations`, `permutationsDerived`, `PointerCData`, `product`, `productDerived`, `ProxyType`, `PyArray`, `PyArrayDerived`, `PyBaseException`, `PyBaseExceptionDerived`, `PyBuiltinClassMethodNarrow`, `PyBuiltinMethod`, `PyBuiltinMethodNarrow`, `PyBuiltinMethodSet`, `PyBytecode`, `PyBZ2Decompressor`, `PyBZ2DecompressorDerived`, `PyCallIter`, `PyCell`, `PyClass`, `PyClassMethod`, `PyClassMethodDerived`, `PyClassMethodDescr`, `PyCompoundCallable`, `PyConnection`, `PyCursor`, `PyDataDescr`, `PyDefaultDict`, `PyDefaultDictDerived`, `PyDeque`, `PyDequeDerived`, `PyDescriptor`, `PyDictionary`, `PyDictionaryDerived`, `PyDictProxy`, `PyEnumerate`, `PyEnumerateDerived`, `PyException`, `PyExtendedCursor`, `PyFastSequenceIter`, `PyFile`, `PyFileDerived`, `PyFileIO`, `PyFileIODerived`, `PyFrame`, `PyFrozenSet`, `PyFrozenSetDerived`, `PyFunction`, `PyGenerator`, `PyIndentationError`, `PyInstance`, `PyIOBase`, `PyIOBaseDerived`, `PyIterator`, `PyJavaPackage`, `PyJavaType`, `PyList`, `PyListDerived`, `PyListIterator`, `PyLocal`, `PyLocalDerived`, `PyMemoryView`, `PyMethod`, `PyMethodDescr`, `PyModule`, `PyModuleDerived`, `PyNewWrapper`, `PyOverridableNew`, `PyPartial`, `PyPartialDerived`, `PyProperty`, `PyPropertyDerived`, `PyRawIOBase`, `PyRawIOBaseDerived`, `PyReader`, `PyReflectedConstructor`, `PyReflectedFunction`, `PyReversedIterator`, `PySequenceIter`, `PySequenceList`, `PySet`, `PySetDerived`, `PySlice`, `PySlot`, `PyStatement`, `PyStaticMethod`, `PyStatResult`, `PyStringMap`, `PySuper`, `PySuperDerived`, `PySyntaxError`, `PySystemState`, `PyTeeIterator`, `PyTeeIteratorDerived`, `PyTimeTuple`, `PyTraceback`, `PyTuple`, `PyTupleDerived`, `PyTupleIterator`, `PyType`, `PyTypeDerived`, `PyVersionInfo`, `PyWriter`, `PyXRangeIter`, `ReferenceType`, `ReferenceTypeDerived`, `repeat`, `repeatDerived`, `ScalarCData`, `Scanner`, `ScannerDerived`, `ScannerObject`, `starmap`, `starmapDerived`, `StringCData`, `StructLayout`, `StructLayout.Field`, `StructLayout.ScalarField`, `Structure`, `synchronize.SynchronizedCallable`, `takewhile`, `takewhileDerived`, `zipimporter`, `zipimporterDerived`

      public interface Traverseproc

  This interface defines a CPython-equivalent traverse-mechanism allowing to detect reference cycles. While this is crucial for cyclic gc support in CPython, it only serves debugging purposes in Jython. As a side-effect it allows a more complete implementation of the gc module.

  Note that implementing this interface is only OPTIONAL. Gc will work fine in Jython without it. Still we took care to have all core classes implement it and recommend third party extension providers to do so as well with custom PyObject-implementations.

  Of course this interface shall only be implemented by `PyObject`s that potentially own direct references to other `PyObject`s. Note that indirect references via non-PyObjects should also be treated as "direct" (c.f. tracefunc in `PyFrame`). `PyObject`s that don't own references to other `PyObject`s under any condition and neither inherit such references from a superclass are strictly recommended to be annotated `Untraversable`.

  Jython's traverse mechanism serves debugging purposes to ease finding memory leaks and compare gc behavior with CPython. While it is of course not required that gc behaviors of Jython and CPython equal, there might arise subtle bugs from these different behaviors. Jython's traverse mechanism is intended to allow finding such bugs by comparing gc behavior to CPython and isolating the Python code that is not robust enough to work invariant under different gc behaviors. See also `gc` for more details on this.

  Further this mechanism is crucial for some aspects of gc-support of the JyNI project. JyNI does not strictly depend on it to emulate CPython's gc for extensions, but would have to perform inefficient reflection-based traversal in some edge-cases (which might also conflict with security managers).

  Note that the slots-array and - if existent - the user-dict of `fooDerived` classes is traversed by `TraverseprocDerived`. The gc-module takes care of exploiting both traverse methods in its static traverse method. So for manual traversion one should always use `gc.traverse(PyObject, Visitproc, Object)` rather than directly calling methods in this interface.

  Also note that `PyObject.objtype` is not subject to `Traverseproc`s by default. In CPython only objects with heap-types traverse their `ob_type`-field. In Jython, `fooDerived`-classes are the equivalents of heapTypes. For such classes `PyObject.objtype` is actually traversed (along with the user dict).

  Note for implementing:
  Every non-static, strong-referenced `PyObject` should be passed to the `Visitproc`. If `Object`s or `interface`-types are referenced where it is not known, whether it is a `PyObject` or references other `PyObjects`, one should check for `PyObject` via `instanceof`. If a non-`PyObject` implements `Traverseproc`, one can traverse it by delegating to its `Traverseproc` methods.
  Warning:
  If one lets non-`PyObject`s implement `Traverseproc`, extreme care must be taken, whether the traverse call shall be passed on to other non-`PyObject` `Traverseproc`-implementers, as this can cause infinite traverse cycles.
  Examples for non-`PyObject`s that implement `Traverseproc` are `PyException` and `Fetch`. A safer, but potentially slower way to deal with non-`PyObject`-`Traverseproc`s or any other non-`PyObject` that might contain references to other `PyObject`s is `gc.traverseByReflection(Object, Visitproc, Object)`. This is for instance used in `PyArray`.

  Examples
  In the following we provide some examples with code-snippets to demonstrate and streamline the writing of `Traverseproc`-implementations.
  Since this peace of API was introduced to enhance a large existing code-base, we recommend to put the `Traverseproc`-implementation always to the end of a class and separate it from the original code by two blank lines and a comment "Traverseproc implementation".
  Let's start with classes that don't hold references to `PyObject`s. If the class extends some other class that implements `Traverseproc`, nothing special needs to be done. For instance, we have this situation in `PySet`. It extends `BaseSet`, which in turn implements `Traverseproc`:

       @ExposedType(name = "set", base = PyObject.class, doc = BuiltinDocs.set_doc)
       public class PySet extends BaseSet {
         ...
       }

  If the class neither contains `PyObject`-references, nor extends some `Traverseproc`-implementing class, it is recommended to be annotated `Untraversable`. `PyInteger` is an example for this:

       @Untraversable
       @ExposedType(name = "int", doc = BuiltinDocs.int_doc)
       public class PyInteger extends PyObject {
         ...
       }

  If there are simply some `PyObject`(-subclass), non-static fields in the class, let it implement `Traverseproc`. Write `traverse(Visitproc, Object)` by just visiting the fields one by one. Check each to be non-`null` previously unless the field cannot be `null` for some good reason. If `Visitproc.visit(PyObject, Object)` returns non-zero, return the result immediately (i.e. abort the traverse process). The following example is taken from `PyMethod`:

        /* Traverseproc implementation */
        @Override
        public int traverse(Visitproc visit, Object arg) {
            int retVal;
            if (im_class != null) {
                retVal = visit.visit(im_class, arg);
                if (retVal != 0) {
                    return retVal;
                }
            }
            if (__func__ != null) {
                retVal = visit.visit(__func__, arg);
                if (retVal != 0) {
                    return retVal;
                }
            }
            return __self__ == null ? 0 : visit.visit(__self__, arg);
        }

  Implement `refersDirectlyTo(PyObject)` by checking the argument to be non-`null` and identity-comparing it to every field:

        @Override
        public boolean refersDirectlyTo(PyObject ob) {
            return ob != null && (ob == im_class || ob == __func__ || ob == __self__);
        }

  If there is a Java-set or other iterable that it is not a `PyObject`, but contains `PyObject`s, visit every element. Don't forget to check for non-`null` if necessary and return immediately, if `Visitproc.visit(PyObject, Object)` returns non-zero. The following example is taken from `BaseSet`:

        /* Traverseproc implementation */
        @Override
        public int traverse(Visitproc visit, Object arg) {
            int retValue;
            for (PyObject ob: _set) {
                if (ob != null) {
                    retValue = visit.visit(ob, arg);
                    if (retValue != 0) {
                        return retValue;
                    }
                }
            }
            return 0;
        }

  In this case, `refersDirectlyTo(PyObject)` can be implemented (potentially) efficiently by using the backing set's `contains`-method:

        @Override
        public boolean refersDirectlyTo(PyObject ob) {
            return ob != null && _set.contains(ob);
        }

  If a class extends a `Traverseproc`-implementing class and adds `PyObject`-references to it, the parent-`traverse`-method should be called initially via `super` (example is taken from `PyJavaType`):

        /* Traverseproc implementation */
        @Override
        public int traverse(Visitproc visit, Object arg) {
            int retVal = super.traverse(visit, arg);
            if (retVal != 0) {
                return retVal;
            }
            if (conflicted != null) {
                for (PyObject ob: conflicted) {
                    if (ob != null) {
                        retVal = visit.visit(ob, arg);
                        if (retVal != 0) {
                            return retVal;
                        }
                    }
                }
            }
            return 0;
        }

  In contrast to that, `refersDirectlyTo(PyObject)` should call its parent-method as late as possible, because that method might throw an `UnsupportedOperationException`. By calling it in the end, we have the chance to fail- or succeed fast before a potential exception occurs:

        @Override
        public boolean refersDirectlyTo(PyObject ob) throws UnsupportedOperationException {
            if (ob == null) {
                return false;
            }
            if (conflicted != null) {
                for (PyObject obj: conflicted) {
                    if (obj == ob) {
                        return true;
                    }
                }
            }
            return super.refersDirectlyTo(ob);
        }

  While reflection-based traversal should be avoided if possible, it can be used to traverse fields that might contain references to `PyObject`s, but cannot be inferred at compile-time. `gc.canLinkToPyObject(Class, boolean)` can help to safe some performance by failing fast if type-info already rules out the possibility of the field holding `PyObject`-references. This technique is for instance used to traverse the content of `PyArray`:

        /* Traverseproc implementation */
        @Override
        public int traverse(Visitproc visit, Object arg) {
            if (data == null || !gc.canLinkToPyObject(data.getClass(), true)) {
                return 0;
            }
            return gc.traverseByReflection(data, visit, arg);
        }

  `gc.canLinkToPyObject(Class, boolean)` also offers a way to let `refersDirectlyTo(PyObject)` fail fast by type-information:

        @Override
        public boolean refersDirectlyTo(PyObject ob)
                throws UnsupportedOperationException {
            if (data == null || !gc.canLinkToPyObject(data.getClass(), true)) {
                return false;
            }
            throw new UnsupportedOperationException();
        }

  List of `PyObject`-subclasses
  We conclude with a list of `PyObject` subclasses in Jython, excluding derived classes.
  `PyObject`-subclasses in Jython checked for need of `Traverseproc`:
  org.python.core:
  __builtin__:
  BuiltinFunctions - no refs, untraversable
  ImportFunction - no refs, untraversable
  SortedFunction - no refs, untraversable
  AllFunction - no refs, untraversable
  AnyFunction - no refs, untraversable
  FormatFunction - no refs, untraversable
  PrintFunction - no refs, untraversable
  MaxFunction - no refs, untraversable
  MinFunction - no refs, untraversable
  RoundFunction - no refs, untraversable
  CompileFunction - no refs, untraversable
  OpenFunction - no refs, untraversable
  NextFunction - no refs, untraversable
  BinFunction - no refs, untraversable
  AstList - Traverseproc
  BaseBytes - no refs, untraversable
  BaseDictionaryView - Traverseproc
  BaseSet - Traverseproc
  ClasspathPyImporter - no refs, untraversable
  ContextGuard: - no PyObject
  ContextCode - Traverseproc
  GeneratorContextManager - Traverseproc
  exceptions - no refs, untraversable
  BoundStaticJavaMethod - no refs, untraversable
  JavaImporter - no refs, untraversable
  JavaProxyList:
  ListMethod - no refs, untraversable (extends PyBuiltinMethodNarrow)
  ListMulProxyClass - no refs, untraversable
  JavaProxyMap:
  MapMethod - no refs, untraversable (extends PyBuiltinMethodNarrow)
  MapClassMethod - no refs, untraversable (extends PyBuiltinClassMethodNarrow)
  JavaProxySet:
  SetMethod - no refs, untraversable (extends PyBuiltinMethodNarrow)
  SetMethodVarargs - no refs, untraversable (extends SetMethod)
  CopyMethod - no refs, untraversable
  IsSubsetMethod - no refs, untraversable
  IsSupersetMethod - no refs, untraversable
  Py:
  JavaCode - Traverseproc
  JavaFunc - no refs, untraversable
  Py2kBuffer - no refs, untraversable
  PyArray - Traverseproc, traverses via reflection
  PyBaseCode - no refs, abstract class
  PyBaseException - Traverseproc
  PyBaseString - no refs, abstract class
  PyBeanEvent - no refs, untraversable
  PyBeanEventProperty - no refs, untraversable
  PyBeanProperty - no refs, untraversable
  PyBoolean - no refs, untraversable
  PyBuffer - no PyObject
  PyBuiltinCallable - no refs, untraversable
  PyBuiltinClassMethodNarrow - no refs, abstract class
  PyBuiltinFunction - no refs, untraversable
  PyBuiltinFunctionNarrow - no refs, untraversable
  PyBuiltinFunctionSet - no refs, untraversable
  PyBuiltinMethod - Traverseproc
  PyBuiltinMethodNarrow - no refs, abstract class
  PyBuiltinMethodSet - Traverseproc
  PyByteArray - no refs, untraversable
  PyBytecode - Traverseproc
  PyStackWhy - no refs, untraversable
  PyStackException - Traverseproc
  PyTryBlock - no refs, untraversable
  PyCallIter - Traverseproc (with call to super)
  PyCell - Traverseproc
  PyClass - Traverseproc
  PyClassMethod - Traverseproc
  PyClassMethodDescr - no refs, untraversable
  PyCode - no refs, abstract class
  PyComplex - no refs, untraversable
  PyCompoundCallable - Traverseproc
  PyDataDescr - no refs, untraversable
  PyDescriptor - Traverseproc
  PyDictionary - Traverseproc
  ValuesIter - no refs, extends PyIterator
  ItemsIter - no refs, extends PyIterator
  PyMapKeyValSet - no PyObject
  PyMapEntrySet - no PyObject
  PyDictProxy - Traverseproc
  PyEllipsis - no refs, untraversable
  PyEnumerate - Traverseproc
  PyFastSequenceIter - Traverseproc
  PyFile - Traverseproc
  PyFileReader - no refs, untraversable
  PyFileWriter - no refs, untraversable
  PyFloat - no refs, untraversable
  PyFrame - Traverseproc
  PyFunction - Traverseproc
  PyGenerator - Traverseproc (with call to super)
  PyIndentationError - no PyObject
  PyInstance - Traverseproc
  PyInteger - no refs, untraversable
  PyIterator - Traverseproc
  PyJavaPackage - Traverseproc
  PyJavaType - Traverseproc (with call to super)
  EnumerationIter - no refs, extends PyIterator
  ComparableMethod - no refs, abstract class
  PyList - Traverseproc
  PyLong - no refs, untraversable
  PyMemoryView - Traverseproc
  PyMethod - Traverseproc
  PyMethodDescr - Traverseproc
  PyModule - Traverseproc
  PyNewWrapper - Traverseproc
  PyNone - no refs, untraversable
  PyNotImplemented - no refs, untraversable
  PyObject - no refs (objtype is special case)
  PyIdentityTuple - Traverseproc
  PyOverridableNew - no refs, abstract class
  PyProperty - Traverseproc
  PyReflectedConstructor - no refs, untraversable
  PyReflectedField - no refs, untraversable
  PyReflectedFunction - Traverseproc
  PyReversedIterator - Traverseproc (with call to super)
  PySequence - no refs, abstract class (default Traverseproc implementation)
  PySequenceIter - Traverseproc (with call to super)
  PySequenceList - no refs, abstract class
  PySingleton - no refs, untraversable
  PySlice - Traverseproc
  PySlot - no refs, untraversable
  PyStaticMethod - Traverseproc
  PyString - no refs, untraversable (assuming baseBuffer is not a PyObject)
  PyStringMap - Traverseproc
  StringMapIter - no refs, extends PyIterator, abstract class
  ItemsIter - no refs, extends StringMapIter
  KeysIter - no refs, extends StringMapIter
  ValuesIter - no refs, extends StringMapIter
  PySuper - Traverseproc
  PySyntaxError - no PyObject
  PySystemState - Traverseproc
  PySystemStateFunctions - no refs, untraversable
  PyAttributeDeleted - no refs, untraversable
  FloatInfo - Traverseproc
  LongInfo - Traverseproc
  PyTableCode - no refs, untraversable
  PyTraceback - Traverseproc
  PyTuple - Traverseproc
  PyType - Traverseproc
  PyUnicode - no refs, untraversable
  PyXRange - no refs, untraversable
  PyXRangeIter - no refs, extends PyIterator
  SyspathArchive - no refs, untraversable
  org.python.core.stringlib:
  FieldNameIterator - no refs, traverses via reflection
  MarkupIterator - no refs, untraversable
  org.python.core.util:
  importer - no refs, abstract class
  org.python.jsr223:
  PyScriptEngineScope - no refs, untraversable
  ScopeIterator - Traverseproc
  org.python.modules:
  _codecs:
  EncodingMap - no refs, untraversable
  _hashlib:
  Hash - no refs, untraversable
  _marshal:
  Marshaller - Traverseproc
  Unmarshaller - Traverseproc
  cStringIO:
  StringIO - no refs, extends PyIterator
  operator:
  OperatorFunctions - no refs, untraversable
  operator - no refs, untraversable
  PyAttrGetter - Traverseproc
  PyItemGetter - Traverseproc
  PyMethodCaller - Traverseproc
  PyStruct - no refs, untraversable
  synchronize:
  SynchronizedCallable - Traverseproc
  org.python.modules._collections:
  PyDefaultDict - Traverseproc (with call to super)
  PyDeque - Traverseproc (assuming, Nodes can't build cycles)
  PyDequeIter - Traverseproc (with call to super)
  org.python.modules._csv:
  PyDialect - no refs, untraversable
  PyReader - Traverseproc (with call to super)
  PyWriter - Traverseproc
  org.python.modules._functools:
  PyPartial - Traverseproc
  org.python.modules._io:
  PyFileIO - no refs, untraversable (there is a final PyString "mode" that is guaranteed to be a PyString and no subclass; as such it needs not be traversed since it cannot have refs itself)
  PyIOBase - Traverseproc
  PyRawIOBase - no refs, extends PyIOBase
  org.python.modules._json:
  Encoder - Traverseproc
  Scanner - Traverseproc
  _json: ScanstringFunction - no refs, untraversable
  EncodeBasestringAsciiFunction - no refs, untraversable
  org.python.modules._jythonlib:
  dict_builder - Traverseproc
  org.python.modules._threading:
  Condition - Traverseproc
  Lock - no refs, untraversable
  org.python.modules._weakref:
  AbstractReference - Traverseproc
  ReferenceType - no refs, extends AbstractReference
  ProxyType - no refs, extends AbstractReference
  CallableProxyType - no refs, extends ProxyType
  org.python.modules.bz2:
  PyBZ2Compressor - no refs, untraversable
  PyBZ2Decompressor - Traverseproc
  PyBZ2File - no refs, untraversable
  BZ2FileIterator - no refs, extends PyIterator
  org.python.modules.itertools:
  chain - Traverseproc (with call to super)
  combinations - Traverseproc (with call to super)
  combinationsWithReplacement - Traverseproc (with call to super)
  compress - Traverseproc (with call to super)
  count - Traverseproc (with call to super)
  cycle - Traverseproc (with call to super)
  dropwhile - Traverseproc (with call to super)
  groupby - Traverseproc (with call to super)
  ifilter - Traverseproc (with call to super)
  ifiIterfalse - Traverseproc (with call to super)
  imap - Traverseproc (with call to super)
  islice - Traverseproc (with call to super)
  itertools:
  ItertoolsIterator - no refs, extends PyIterator, abstract class
  FilterIterator - Traverseproc, extends ItertoolsIterator
  WhileIterator - Traverseproc, extends ItertoolsIterator izip - Traverseproc (with call to super)
  izipLongest - Traverseproc (with call to super)
  permutations - Traverseproc (with call to super)
  product - Traverseproc (with call to super)
  PyTeeIterator - Traverseproc (with call to super)
  repeat - Traverseproc (with call to super)
  starmap - Traverseproc (with call to super)
  takewhile - Traverseproc (with call to super)
  org.python.modules.jffi:
  ArrayCData - Traverseproc (with call to super; maybe check referenceMemory field whether it extends PyObject)
  ArrayIter - no refs, extends PyIterator
  BasePointer - no refs, abstract class
  ByReference - no refs, untraversable (maybe check memory field whether it extends PyObject)
  CData - Traverseproc (maybe check referenceMemory field whether it extends PyObject)
  CType - no refs, abstract class
  Builtin - no refs, untraversable
  DynamicLibrary - no refs, untraversable
  StructLayout:
  Field - Traverseproc
  org.python.modules.posix:
  PosixModule:
  FstatFunction - no refs, untraversable
  LstatFunction - no refs, untraversable
  StatFunction - no refs, untraversable
  WindowsStatFunction - no refs, untraversable
  PyStatResult - Traverseproc (with call to super)
  org.python.modules.random:
  PyRandom - no refs, untraversable
  org.python.modules.sre:
  MatchObject - Traverseproc
  PatternObject - Traverseproc
  ScannerObject - Traverseproc
  org.python.modules.thread:
  PyLocal - Traverseproc
  PyLock - no refs, untraversable
  org.python.modules.time:
  PyTimeTuple - Traverseproc (with call to super)
  Time:
  TimeFunctions - no refs, untraversable
  org.python.modules.zipimport:
  zipimporter - Traverseproc
  org.python.util:
  InteractiveInterpreter - no PyObject
  com.ziclix.python.sql:
  DBApiType - no refs, untraversable
  PyConnection - Traverseproc
  ConnectionFunc - no refs, extends PyBuiltinMethodSet
  PyCursor - Traverseproc
  CursorFunc - no refs, extends PyBuiltinMethodSet
  PyExtendedCursor - no refs, extends PyCursor
  ExtendedCursorFunc - no refs, extends PyBuiltinMethodSet
  PyStatement - Traverseproc (because Object sql could be a PyObject or Traverseproc)
  zxJDBC - no refs, untraversable
  zxJDBCFunc - no refs, untraversable
  com.ziclix.python.sql.connect:
  Connect - no refs, untraversable
  Connectx - no refs, untraversable
  Lookup - no refs, untraversable
  com.ziclix.python.sql.util:
  BCP - Traverseproc
  BCPFunc - no refs, extends PyBuiltinMethodSet
  org.python.antlr:
  AnalyzingParser:
  AnalyzerTreeAdaptor - no PyObject
  AST - no refs, untraversable
  PythonErrorNode - no refs, extends PythonTree
  PythonTree - Traverseproc
  org.python.antlr.ast:
  alias - no refs, extends PythonTree
  arguments - Traverseproc (with call to super)
  comprehension - Traverseproc (with call to super)
  keyword - Traverseproc (with call to super)
  org.python.antlr.base:
  boolop - no refs, extends PythonTree
  cmpop - no refs, extends PythonTree
  excepthandler - no refs, extends PythonTree
  expr_context - no refs, extends PythonTree
  expr - no refs, extends PythonTree
  mod - no refs, extends PythonTree
  operator - no refs, extends PythonTree
  slice - no refs, extends PythonTree
  stmt - no refs, extends PythonTree
  unaryop - no refs, extends PythonTree
  org.python.antlr.op:
  Add - no refs, extends PythonTree
  And - no refs, extends PythonTree
  AugLoad - no refs, extends PythonTree
  AugStore - no refs, extends PythonTree
  BitAnd - no refs, extends PythonTree
  BitOr - no refs, extends PythonTree
  BitXor - no refs, extends PythonTree
  Del - no refs, extends PythonTree
  Div - no refs, extends PythonTree
  Eq - no refs, extends PythonTree
  FloorDiv - no refs, extends PythonTree
  Gt - no refs, extends PythonTree
  GtE - no refs, extends PythonTree
  In - no refs, extends PythonTree
  Invert - no refs, extends PythonTree
  Is - no refs, extends PythonTree
  IsNot - no refs, extends PythonTree
  Load - no refs, extends PythonTree
  LShift - no refs, extends PythonTree
  Lt - no refs, extends PythonTree
  LtE - no refs, extends PythonTree
  Mod - no refs, extends PythonTree
  Mult - no refs, extends PythonTree
  Not - no refs, extends PythonTree
  NotEq - no refs, extends PythonTree
  NotIn - no refs, extends PythonTree
  Or - no refs, extends PythonTree
  Param - no refs, extends PythonTree
  Pow - no refs, extends PythonTree
  RShift - no refs, extends PythonTree
  Store - no refs, extends PythonTree
  Sub - no refs, extends PythonTree
  UAdd - no refs, extends PythonTree
  USub - no refs, extends PythonTree

  See Also:
    `Untraversable`, `Visitproc`, `gc.traverse(PyObject, Visitproc, Object)`, `gc.traverseByReflection(Object, Visitproc, Object)`, `gc.canLinkToPyObject(Class, boolean)`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | `refersDirectlyTo​(PyObject ob)` | Optional operation.
    `int` | `traverse​(Visitproc visit, java.lang.Object arg)` | Traverses all directly contained `PyObject`s.

- - ### Method Detail

    - #### traverse

          int traverse​(Visitproc visit,
                       java.lang.Object arg)

      Traverses all directly contained `PyObject`s. Like in CPython, `arg` must be passed unmodified to `visit` as its second parameter. If `Visitproc.visit(PyObject, Object)` returns nonzero, this return value must be returned immediately by traverse. `Visitproc.visit(PyObject, Object)` must not be called with a `null` PyObject-argument.

    - #### refersDirectlyTo

          boolean refersDirectlyTo​(PyObject ob)
                            throws java.lang.UnsupportedOperationException

      Optional operation. Should only be implemented if it is more efficient than calling `traverse(Visitproc, Object)` with a visitproc that just watches out for `ob`. Must return `false` if `ob` is `null`.
      Throws:
        `java.lang.UnsupportedOperationException`