// I guess "transitive total object size" or something

// would be a better name.

sclass RecursiveObjectSize {

  long size;

  new SimpleStack stack;

  Set seen = new CompactIdentityHashSet; // add objects here to ignore them

  Set<Field> fieldsToIgnore;

  Set<S> realmsToIgnore;

  settable int dummySizeForUnknownObject = 24;

  settable bool skipTransientFields;

  swappable void onNewObject(O o) {}

  swappable void onSizeChanged() {}

  swappable bool shouldIgnore(O o) { false; }

  void resize(int expectedObjectCount) {

    seen = new CompactIdentityHashSet(expectedObjectCount);

  }

  void incSize(long n) {

    size += n;

    onSizeChanged();

  }

  long recurse(O o) {

    if (o == null) ret 0;

    seen.add(o);

    stack.add(o);

    while ping (nempty(stack))

      step(popLast(stack));

    ret size;

  }

  void step(O o) {

    if (guessDeepObjectSize_shouldIgnoreObject(o)) ret;

    if (shouldIgnore(o)) ret;

    onNewObject(o);

    if (realmsToIgnore != null && contains(realmsToIgnore, getRealm(o))) ret;

    ifdef RecursiveObjectSize_debug

      print("gos: " + getClassName(o));

    endifdef

    if (o instanceof Class) ret;

    if (isInstanceOfSyntheticClass(o))

      ret with incSize(dummySizeForUnknownObject());

    incSize(unsafe_sizeOf(o));

    if (o cast O[]) {

      for (O x : o)

        if (x != null && seen.add(x)) stack.add(x);

      ret;

    }

    if (sizeCalculation_shouldSkipObject(o)) ret;

    for (Field f : nonStaticNonPrimitiveFieldObjects(o)) {

      if (contains(fieldsToIgnore, f)) continue;

      if (skipTransientFields && isTransient(f)) continue;

      O x;

      try {

        x = f.get(o);

      } catch e {

        print("Error trying to access " + f + ": " + e);

        continue;

      }

      if (x != null && seen.add(x)) {

        stack.add(x);

        ifdef RecursiveObjectSize_debug

          print("gos field " + f + ": " + getClassName(x));

        endifdef

      }

    }

    //fail("can't handle object type: " + className(o));

  }

  bool hasSeen(O o) {

    ret seen.contains(o);

  }

}