[Fix #197]: Add Sample Objects query

[kgibm]

Fixes #197

[jasonk000]

Small changes here, and one bug. Direction is good.

[jasonk000]

I like this approach of allowing many sample types.

[jasonk000]

To avoid extra boxing, we can use the form:

return Long.compare(snapshot.getRetainedHeapSize(y), snapshot.getRetainedHeapSize(x));

[jasonk000]

Not sure if this is validated in UI? I think it needs to be checked as >= 0.

[jasonk000]

This looks like an off by one, eg:

[5 6 7 8], length = 4, number = 1, target = 3.

System.arraycopy(objectIds, objectIds.length - number - 1, finalObjectIds, 0, number);
System.arraycopy(objectIds, 4 - 1 - 1, finalObjectIds, 0, 1);
System.arraycopy(objectIds, 2, finalObjectIds, 0, 1);

So I think this will get us [7], but I expect we want [8]?

[jasonk000]

could this be <= ? e.g length = 0, number = 0 ;; or length = 5, number = 5, could all match

[jasonk000]

Maybe we can add extra test for the LAST.

[jasonk000]

And some more .. the '0', '-ve', and other boundary conditions.

[jasonk000]

Could add a try/finally around the whole fn to unwrap and rethrow the wrapped SnapshotException? An extra method layer to wrap the query implementation can keep it tidy.

[kgibm]

I initially tried that but I was surprised to find it didn't work because getRetainedHeapSize and getHeapSize throw the checked exception SnapshotException but sorted doesn't throw that exception so handling outside of sorted doesn't work. I'm still a bit curmudgeony and haven't fully mentally migrated to closures in Java but this seems like a huge oversight in the language that could have made closures much cleaner.

[jasonk000]

handling outside of sorted doesn't work

Good point!

huge oversight in the language that could have made closures much cleaner

Yes, checked exceptions are a headache. Basically we need to create a @FunctionalInterface single-method interface that has the SnapshotException in the signature.

(not critical for change but may be some inspiration!, LLM whipped it up)

@FunctionalInterface
private interface SnapshotLongFunction<T>
{
    long applyAsLong(T value) throws SnapshotException;
}

private static <T> Comparator<T> comparingSnapshot(SnapshotLongFunction<T> function,
                boolean reversed)
{
    return (left, right) -> {
        try
        {
            long l = function.applyAsLong(left);
            long r = function.applyAsLong(right);
            return reversed ? Long.compare(r, l) : Long.compare(l, r);
        }
        catch (SnapshotException e)
        {
            throw new RuntimeException(e);
        }
    };
}

Now we can call:

...
.sorted(comparingSnapshot(snapshot::getRetainedHeapSize, true))

[kgibm]

Interesting. Speaking of which, I'm not sure what the policy is for LLMs for Eclipse and/or MAT? I'm still a bit curmudgeonly with LLMs, too, so I haven't even looked into the policies yet

[kgibm]

Found Eclipse AI guidelines here: https://www.eclipse.org/projects/handbook/#genai