Add Cache.getAllPresent()

[BoD]

Description

Adds getAllPresent() with no argument to Cache, in addition to existing getAllPresent(keys: List<*>).
In the original Guava library there was an asMap() method which could be used to get the contents of the cache.

Type of Change

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to not work as expected)
• This change requires a documentation update

Test Plan

Removed @Ignore from the getAllPresent() test.

Checklist:

Before submitting your PR, please review and check all of the following:

• I have performed a self-review of my own code
• I have commented my code, particularly in hard-to-understand areas
• I have made corresponding changes to the documentation (N/A)
• My changes generate no new warnings
• I have added tests that prove my change is effective
• New and existing unit tests pass locally with my changes

Additional Notes:

Used clear() as an inspiration for the implementation.

[BoD]

Added this for source compatibility of potential implementers of Cache. Let me know if you think this is unnecessary.

[matt-ramotar]

I'm not sure if this is necessary, though appreciate you thinking about this. @digitalbuddha @yigit - thoughts?

[digitalbuddha]

couldn't hurt

[matt-ramotar]

I think this is reasonable. Can you please include an explanation:

/**
 * The default implementation provided here throws a [NotImplementedError] to maintain backward compatibility for existing implementations.
 * /

[matt-ramotar]

Please document the default method, otherwise LGTM and I will be around to stamp. I see the other tickets - when do you need a release?

[hoc081098]

Can invert if condition and return eagerly to avoid a nested indentation level 🙏

[BoD]

Please document the default method, otherwise LGTM and I will be around to stamp. I see the other tickets - when do you need a release?

🙏 I've addressed the comments 👍

A release is not urgent, for now we've bundled the classes in the project - whenever you make a release, we'll use the dependency instead.

[digitalbuddha]

nit:
To make the function more efficient, we can consider a few optimizations:

Avoid creating a new map if there are no active entries: Instead of always creating a new map using buildMap, we can check if any active entries were found during the iteration. If no active entries are found, we can return an empty map directly.

Use a mutable map to avoid extra memory allocation:
When you use buildMap, it creates a new read-only map and copies the elements into it. This means that there is an additional step of creating a new map and copying the elements from the builder to the final map. This extra step introduces some overhead in terms of memory allocation and copying.

Instead of using buildMap, which creates a new map, we can use a mutable map like mutableMapOf() and populate it directly. This avoids the extra memory allocation and copying overhead.

fun activeEntries(): Map<K, V> {
    // read-volatile
    if (count.value == 0) return emptyMap()

    reentrantLock.lock()
    return try {
        val activeMap = mutableMapOf<K, V>()
        val table = table.value
        for (i in 0 until table.size) {
            var e = table[i]
            while (e != null) {
                if (e.valueReference?.isActive == true) {
                    activeMap[e.key] = e.valueReference.get()!!
                }
                e = e.next
            }
        }
        activeMap.ifEmpty { emptyMap() }
    } finally {
        reentrantLock.unlock()
    }
}