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, Fetch, FieldNameIterator, Function, groupby, groupbyDerived, ifilter, ifilterDerived, ifilterfalse, ifilterfalseDerived, imap, 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, 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 PyObjects that potentially own direct references to other PyObjects. Note that indirect references via non-PyObjects should also be treated as "direct" (c.f. tracefunc in PyFrame). PyObjects that don't own references to other PyObjects 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 org.python.core.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 Traverseprocs 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 Objects 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-PyObjects 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-PyObjects that implement Traverseproc are PyException and Fetch. A safer, but potentially slower way to deal with non-PyObject-Traverseprocs or any other non-PyObject that might contain references to other PyObjects 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 PyObjects. 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 PyObjects, 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 PyObjects, 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 Detail

      • traverse

        int traverse​(Visitproc visit,
                     java.lang.Object arg)
        Traverses all directly contained PyObjects. 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