Module org.cojen.tupl
Package org.cojen.tupl

Interface View

All Known Subinterfaces:
Index
public interface View
Mapping of keys to values, in no particular order. Subclasses and implementations may specify an explicit ordering.
See Also:

  • Method Summary

    Modifier and Type
    Method
    Description
    default Comparator<byte[]>
    comparator()
    Returns a key comparator for the ordering of this view, or null if unordered.
    default long
    count(byte[] lowKey, boolean lowInclusive, byte[] highKey, boolean highInclusive)
    Non-transactionally counts the number of entries within the given range.
    default long
    count(byte[] lowKey, byte[] highKey)
    Non-transactionally counts the number of entries within the given range.
    default boolean
    delete(Transaction txn, byte[] key)
    Unconditionally removes the entry associated with the given key.
    default byte[]
    exchange(Transaction txn, byte[] key, byte[] value)
    Unconditionally associates a value with the given key, returning the previous value.
    default boolean
    exists(Transaction txn, byte[] key)
    Checks if an entry for the given key exists.
    default boolean
    insert(Transaction txn, byte[] key, byte[] value)
    Associates a value with the given key, unless a corresponding value already exists.
    default boolean
    isEmpty()
    Non-transactionally determines if the view has nothing in it.
    default boolean
    isModifyAtomic()
    Returns true if the value-modifying methods of this view are atomic, even when not using transactions.
    boolean
    isUnmodifiable()
    Returns true if any attempt to modify this view causes an UnmodifiableViewException to be thrown.
    default byte[]
    load(Transaction txn, byte[] key)
    Returns a copy of the value for the given key, or null if no matching entry exists.
    LockResult
    lockCheck(Transaction txn, byte[] key)
    Checks the lock ownership for the given key.
    LockResult
    lockExclusive(Transaction txn, byte[] key)
    Explicitly acquire an exclusive lock for the given key, denying any additional locks.
    LockResult
    lockShared(Transaction txn, byte[] key)
    Explicitly acquire a shared lock for the given key, denying exclusive locks.
    LockResult
    lockUpgradable(Transaction txn, byte[] key)
    Explicitly acquire an upgradable lock for the given key, denying exclusive and additional upgradable locks.
    default Cursor
    newAccessor(Transaction txn, byte[] key)
    Returns a cursor intended for accessing values in chunks, permitting them to be larger than what can fit in main memory.
    Cursor
    newCursor(Transaction txn)
    Returns a new cursor over this view.
    default Transaction
    newTransaction(DurabilityMode durabilityMode)
    Returns a new transaction which is compatible with this view.
    Ordering
    ordering()
    Returns the key ordering for this view.
    default boolean
    remove(Transaction txn, byte[] key, byte[] value)
    Removes the entry associated with the given key, but only if the given value matches.
    default boolean
    replace(Transaction txn, byte[] key, byte[] value)
    Associates a value with the given key, but only if a corresponding value already exists.
    default void
    store(Transaction txn, byte[] key, byte[] value)
    Unconditionally associates a value with the given key.
    default LockResult
    touch(Transaction txn, byte[] key)
    Touch the given key as if calling load, but instead only acquiring any necessary locks.
    default LockResult
    tryLockExclusive(Transaction txn, byte[] key, long nanosTimeout)
    Explicitly acquire an exclusive lock for the given key, denying any additional locks.
    default LockResult
    tryLockShared(Transaction txn, byte[] key, long nanosTimeout)
    Explicitly acquire a shared lock for the given key, denying exclusive locks.
    default LockResult
    tryLockUpgradable(Transaction txn, byte[] key, long nanosTimeout)
    Explicitly acquire an upgradable lock for the given key, denying exclusive and additional upgradable locks.
    default boolean
    update(Transaction txn, byte[] key, byte[] value)
    Associates a value with the given key, but only if the given value differs from the existing value.
    default boolean
    update(Transaction txn, byte[] key, byte[] oldValue, byte[] newValue)
    Associates a value with the given key, but only if the given old value matches the existing value.
    default View
    viewDifference(Combiner combiner, View second)
    Returns a view which represents the set difference of this view and a second one.
    default View
    viewFiltered(Filter filter)
    Returns a sub-view, backed by this one, whose entries have been filtered out.
    default View
    viewGe(byte[] key)
    Returns a sub-view, backed by this one, whose keys are greater than or equal to the given key.
    default View
    viewGt(byte[] key)
    Returns a sub-view, backed by this one, whose keys are greater than the given key.
    default View
    viewIntersection(Combiner combiner, View second)
    Returns a view which represents the set intersection of this view and a second one.
    default View
    viewKeys()
    Returns a view, backed by this one, which only provides the keys.
    default View
    viewLe(byte[] key)
    Returns a sub-view, backed by this one, whose keys are less than or equal to the given key.
    default View
    viewLt(byte[] key)
    Returns a sub-view, backed by this one, whose keys are less than the given key.
    default View
    viewPrefix(byte[] prefix, int trim)
    Returns a sub-view, backed by this one, whose keys start with the given prefix.
    default View
    viewReverse()
    Returns a view, backed by this one, whose natural order is reversed.
    default View
    viewTransformed(Transformer transformer)
    Returns a sub-view, backed by this one, whose entries have been filtered out and transformed.
    default View
    viewUnion(Combiner combiner, View second)
    Returns a view which represents the set union of this view and a second one.
    default View
    viewUnmodifiable()
    Returns a view, backed by this one, whose entries cannot be modified.

  • Method Details

    • ordering

      Ordering ordering()
      Returns the key ordering for this view.

    • comparator

      default Comparator<byte[]> comparator()
      Returns a key comparator for the ordering of this view, or null if unordered.

    • newCursor

      Cursor newCursor(Transaction txn)
      Returns a new cursor over this view.

      Note that passing null for the transaction doesn't provide cursor stability with respect to updates. Pass an explicit transaction and call commit to apply each update.

      Parameters:
      txn - optional transaction for Cursor to link to; pass null for auto-commit mode
      Returns:
      a new unpositioned cursor
      Throws:
      IllegalStateException - if transaction belongs to another database instance

    • newAccessor

      default Cursor newAccessor(Transaction txn, byte[] key) throws IOException
      Returns a cursor intended for accessing values in chunks, permitting them to be larger than what can fit in main memory. Essentially, this is a convenience method which disables autoload, and then positions the cursor at the given key.

      Note that passing null for the transaction doesn't provide cursor stability with respect to updates. Instead, pass an explicit transaction and call commit to apply each update.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      Returns:
      non-null cursor
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if key is not allowed
      IOException

    • newTransaction

      default Transaction newTransaction(DurabilityMode durabilityMode)
      Returns a new transaction which is compatible with this view. If the provided durability mode is null, a default mode is selected.
      Throws:
      UnsupportedOperationException - if not supported

    • isEmpty

      default boolean isEmpty() throws IOException
      Non-transactionally determines if the view has nothing in it. If any transactions are concurrently accessing the view, the implementation might return false even though the count method would have returned zero. A return value of true always guarantees that the count is zero. In other words, false negatives are possible, but false positives aren't.
      Throws:
      IOException

    • count

      default long count(byte[] lowKey, byte[] highKey) throws IOException
      Non-transactionally counts the number of entries within the given range. Implementations of this method typically scan over the entries, and so it shouldn't be expected to run in constant time.
      Parameters:
      lowKey - inclusive lowest key in the counted range; pass null for open range
      highKey - exclusive highest key in the counted range; pass null for open range
      Throws:
      IOException

    • count

      default long count(byte[] lowKey, boolean lowInclusive, byte[] highKey, boolean highInclusive) throws IOException
      Non-transactionally counts the number of entries within the given range. Implementations of this method typically scan over the entries, and so it shouldn't be expected to run in constant time.
      Parameters:
      lowKey - lowest key in the counted range; pass null for open range
      lowInclusive - true for inclusive key, false for exclusive, ignored if key is null
      highKey - highest key in the counted range; pass null for open range
      highInclusive - true for inclusive key, false for exclusive, ignored if key is null
      Throws:
      IOException

    • load

      default byte[] load(Transaction txn, byte[] key) throws IOException
      Returns a copy of the value for the given key, or null if no matching entry exists.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for READ_COMMITTED locking behavior
      key - non-null key
      Returns:
      copy of value, or null if entry doesn't exist
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      IOException

    • exists

      default boolean exists(Transaction txn, byte[] key) throws IOException
      Checks if an entry for the given key exists. This method should be called only if the value doesn't need to be loaded or stored — calling exists and then calling a load or store method is typically less efficient than skipping the exists check entirely.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for READ_COMMITTED locking behavior
      key - non-null key
      Returns:
      true if entry exists
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      IOException

    • store

      default void store(Transaction txn, byte[] key, byte[] value) throws IOException
      Unconditionally associates a value with the given key.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      value - value to store; pass null to delete
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if entry is not permitted
      IOException

    • exchange

      default byte[] exchange(Transaction txn, byte[] key, byte[] value) throws IOException
      Unconditionally associates a value with the given key, returning the previous value.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      value - value to store; pass null to delete
      Returns:
      copy of previous value, or null if none
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if entry is not permitted
      IOException

    • insert

      default boolean insert(Transaction txn, byte[] key, byte[] value) throws IOException
      Associates a value with the given key, unless a corresponding value already exists. Equivalent to: update(txn, key, null, value)

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      value - value to insert, which can be null
      Returns:
      false if entry already exists
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if entry is not permitted
      IOException

    • replace

      default boolean replace(Transaction txn, byte[] key, byte[] value) throws IOException
      Associates a value with the given key, but only if a corresponding value already exists.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      value - value to insert; pass null to delete
      Returns:
      false if no existing entry
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if entry is not permitted
      IOException

    • update

      default boolean update(Transaction txn, byte[] key, byte[] value) throws IOException
      Associates a value with the given key, but only if the given value differs from the existing value.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      value - value to update to; pass null to delete
      Returns:
      false if given value matches existing value
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if entry is not permitted
      IOException

    • update

      default boolean update(Transaction txn, byte[] key, byte[] oldValue, byte[] newValue) throws IOException
      Associates a value with the given key, but only if the given old value matches the existing value.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      oldValue - expected existing value, which can be null
      newValue - new value to update to; pass null to delete
      Returns:
      false if existing value doesn't match
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if entry is not permitted
      IOException

    • delete

      default boolean delete(Transaction txn, byte[] key) throws IOException
      Unconditionally removes the entry associated with the given key. Equivalent to: replace(txn, key, null)

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      Returns:
      false if no existing entry
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if remove is not permitted
      IOException

    • remove

      default boolean remove(Transaction txn, byte[] key, byte[] value) throws IOException
      Removes the entry associated with the given key, but only if the given value matches. Equivalent to: update(txn, key, value, null)

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for auto-commit mode
      key - non-null key
      value - expected existing value, which can be null
      Returns:
      false if existing value doesn't match
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if remove is not permitted
      IOException

    • touch

      default LockResult touch(Transaction txn, byte[] key) throws LockFailureException
      Touch the given key as if calling load, but instead only acquiring any necessary locks. Method may return UNOWNED if the key isn't supported by this view, or if the transaction LockMode doesn't retain locks.

      If the entry must be locked, ownership of the key instance is transferred. The key must not be modified after calling this method.

      Parameters:
      txn - optional transaction; pass null for READ_COMMITTED locking behavior
      key - non-null key
      Returns:
      UNOWNED, ACQUIRED, OWNED_SHARED, OWNED_UPGRADABLE, or OWNED_EXCLUSIVE
      Throws:
      NullPointerException - if key is null
      IllegalStateException - if transaction belongs to another database instance
      LockFailureException

    • tryLockShared

      default LockResult tryLockShared(Transaction txn, byte[] key, long nanosTimeout) throws DeadlockException, LockFailureException, ViewConstraintException
      Explicitly acquire a shared lock for the given key, denying exclusive locks. Lock is retained until the end of the transaction or scope.

      Transactions acquire locks automatically, and so use of this method is not required. Ownership of the key instance is transferred, and so the key must not be modified after calling this method.

      Parameters:
      key - non-null key to lock; instance is not cloned and so it must not be modified after calling this method
      nanosTimeout - maximum time to wait for lock; negative timeout is infinite
      Returns:
      INTERRUPTED, TIMED_OUT_LOCK, ACQUIRED, OWNED_SHARED, OWNED_UPGRADABLE, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      IllegalStateException - if too many shared locks
      DeadlockException - if deadlock was detected after waiting the full timeout, unless the timeout is zero
      ViewConstraintException - if key is not allowed
      LockFailureException

    • lockShared

      LockResult lockShared(Transaction txn, byte[] key) throws LockFailureException, ViewConstraintException
      Explicitly acquire a shared lock for the given key, denying exclusive locks. Lock is retained until the end of the transaction or scope.

      Transactions acquire locks automatically, and so use of this method is not required. Ownership of the key instance is transferred, and so the key must not be modified after calling this method.

      Parameters:
      key - non-null key to lock; instance is not cloned and so it must not be modified after calling this method
      Returns:
      ACQUIRED, OWNED_SHARED, OWNED_UPGRADABLE, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      IllegalStateException - if too many shared locks
      LockFailureException - if interrupted or timed out
      DeadlockException - if deadlock was detected after waiting the full timeout
      ViewConstraintException - if key is not allowed

    • tryLockUpgradable

      default LockResult tryLockUpgradable(Transaction txn, byte[] key, long nanosTimeout) throws DeadlockException, LockFailureException, ViewConstraintException
      Explicitly acquire an upgradable lock for the given key, denying exclusive and additional upgradable locks. Lock is retained until the end of the transaction or scope.

      Transactions acquire locks automatically, and so use of this method is not required. Ownership of the key instance is transferred, and so the key must not be modified after calling this method.

      Parameters:
      key - non-null key to lock; instance is not cloned and so it must not be modified after calling this method
      nanosTimeout - maximum time to wait for lock; negative timeout is infinite
      Returns:
      ILLEGAL, INTERRUPTED, TIMED_OUT_LOCK, ACQUIRED, OWNED_UPGRADABLE, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      DeadlockException - if deadlock was detected after waiting the full timeout, unless the timeout is zero
      ViewConstraintException - if key is not allowed
      LockFailureException

    • lockUpgradable

      LockResult lockUpgradable(Transaction txn, byte[] key) throws LockFailureException, ViewConstraintException
      Explicitly acquire an upgradable lock for the given key, denying exclusive and additional upgradable locks. Lock is retained until the end of the transaction or scope.

      Transactions acquire locks automatically, and so use of this method is not required. Ownership of the key instance is transferred, and so the key must not be modified after calling this method.

      Parameters:
      key - non-null key to lock; instance is not cloned and so it must not be modified after calling this method
      Returns:
      ACQUIRED, OWNED_UPGRADABLE, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      LockFailureException - if interrupted, timed out, or illegal upgrade
      DeadlockException - if deadlock was detected after waiting the full timeout
      ViewConstraintException - if key is not allowed

    • tryLockExclusive

      default LockResult tryLockExclusive(Transaction txn, byte[] key, long nanosTimeout) throws DeadlockException, LockFailureException, ViewConstraintException
      Explicitly acquire an exclusive lock for the given key, denying any additional locks. Lock is retained until the end of the transaction or scope.

      Transactions acquire locks automatically, and so use of this method is not required. Ownership of the key instance is transferred, and so the key must not be modified after calling this method.

      Parameters:
      key - non-null key to lock; instance is not cloned and so it must not be modified after calling this method
      nanosTimeout - maximum time to wait for lock; negative timeout is infinite
      Returns:
      ILLEGAL, INTERRUPTED, TIMED_OUT_LOCK, ACQUIRED, UPGRADED, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      DeadlockException - if deadlock was detected after waiting the full timeout, unless the timeout is zero
      ViewConstraintException - if key is not allowed
      LockFailureException

    • lockExclusive

      LockResult lockExclusive(Transaction txn, byte[] key) throws LockFailureException, ViewConstraintException
      Explicitly acquire an exclusive lock for the given key, denying any additional locks. Lock is retained until the end of the transaction or scope.

      Transactions acquire locks automatically, and so use of this method is not required. Ownership of the key instance is transferred, and so the key must not be modified after calling this method.

      Parameters:
      key - non-null key to lock; instance is not cloned and so it must not be modified after calling this method
      Returns:
      ACQUIRED, UPGRADED, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      LockFailureException - if interrupted, timed out, or illegal upgrade
      DeadlockException - if deadlock was detected after waiting the full timeout
      ViewConstraintException - if key is not allowed

    • lockCheck

      LockResult lockCheck(Transaction txn, byte[] key) throws ViewConstraintException
      Checks the lock ownership for the given key.
      Returns:
      UNOWNED, OWNED_SHARED, OWNED_UPGRADABLE, or OWNED_EXCLUSIVE
      Throws:
      IllegalStateException - if transaction belongs to another database instance
      ViewConstraintException - if key is not allowed

    • viewGe

      default View viewGe(byte[] key)
      Returns a sub-view, backed by this one, whose keys are greater than or equal to the given key. Ownership of the key instance is transferred, and so it must not be modified after calling this method.

      The returned view will throw a ViewConstraintException on an attempt to insert a key outside its range.

      Throws:
      UnsupportedOperationException - if view is unordered
      NullPointerException - if key is null

    • viewGt

      default View viewGt(byte[] key)
      Returns a sub-view, backed by this one, whose keys are greater than the given key. Ownership of the key instance is transferred, and so it must not be modified after calling this method.

      The returned view will throw a ViewConstraintException on an attempt to insert a key outside its range.

      Throws:
      UnsupportedOperationException - if view is unordered
      NullPointerException - if key is null

    • viewLe

      default View viewLe(byte[] key)
      Returns a sub-view, backed by this one, whose keys are less than or equal to the given key. Ownership of the key instance is transferred, and so it must not be modified after calling this method.

      The returned view will throw a ViewConstraintException on an attempt to insert a key outside its range.

      Throws:
      UnsupportedOperationException - if view is unordered
      NullPointerException - if key is null

    • viewLt

      default View viewLt(byte[] key)
      Returns a sub-view, backed by this one, whose keys are less than the given key. Ownership of the key instance is transferred, and so it must not be modified after calling this method.

      The returned view will throw a ViewConstraintException on an attempt to insert a key outside its range.

      Throws:
      UnsupportedOperationException - if view is unordered
      NullPointerException - if key is null

    • viewPrefix

      default View viewPrefix(byte[] prefix, int trim)
      Returns a sub-view, backed by this one, whose keys start with the given prefix. Ownership of the prefix instance is transferred, and so it must not be modified after calling this method.

      The returned view will throw a ViewConstraintException on an attempt to insert a key outside its range.

      Parameters:
      trim - amount of prefix length to trim from all keys in the view
      Throws:
      UnsupportedOperationException - if view is unordered
      NullPointerException - if prefix is null
      IllegalArgumentException - if trim is longer than prefix

    • viewTransformed

      default View viewTransformed(Transformer transformer)
      Returns a sub-view, backed by this one, whose entries have been filtered out and transformed.

      The returned view will throw a ViewConstraintException on an attempt to insert an entry not supported by the transformer.

      Throws:
      NullPointerException - if transformer is null

    • viewFiltered

      default View viewFiltered(Filter filter)
      Returns a sub-view, backed by this one, whose entries have been filtered out.

      The returned view will throw a ViewConstraintException on an attempt to insert an entry not supported by the filter.

      Throws:
      NullPointerException - if filter is null

    • viewUnion

      default View viewUnion(Combiner combiner, View second)
      Returns a view which represents the set union of this view and a second one. A union eliminates duplicate keys, by relying on a combiner to decide how to deal with them. If the combiner chooses to discard duplicate keys, then the returned view represents the symmetric set difference instead.

      Storing entries in the union is permitted, if the combiner supports separation. The separator must supply at least one non-null value, or else a ViewConstraintException will be thrown.

      Parameters:
      combiner - combines common entries together; pass null to always choose the first
      second - required second view in the union
      Throws:
      NullPointerException - if second view is null
      IllegalArgumentException - if the views don't define a consistent ordering, as specified by their comparators

    • viewIntersection

      default View viewIntersection(Combiner combiner, View second)
      Returns a view which represents the set intersection of this view and a second one. An intersection eliminates duplicate keys, by relying on a combiner to decide how to deal with them.

      Storing entries in the intersection is permitted, if the combiner supports separation. The separator must supply two non-null values, or else a ViewConstraintException will be thrown.

      Parameters:
      combiner - combines common entries together; pass null to always choose the first
      second - required second view in the intersection
      Throws:
      NullPointerException - if second view is null
      IllegalArgumentException - if the views don't define a consistent ordering, as specified by their comparators

    • viewDifference

      default View viewDifference(Combiner combiner, View second)
      Returns a view which represents the set difference of this view and a second one. A difference eliminates duplicate keys, by relying on a combiner to decide how to deal with them.

      Storing entries in the difference is permitted, if the combiner supports separation. The separator must supply a non-null first value, or else a ViewConstraintException will be thrown.

      Parameters:
      combiner - combines common entries together; pass null to always discard them
      second - required second view in the difference
      Throws:
      NullPointerException - if second view is null
      IllegalArgumentException - if the views don't define a consistent ordering, as specified by their comparators

    • viewKeys

      default View viewKeys()
      Returns a view, backed by this one, which only provides the keys. Values are always represented as NOT_LOADED, and attempting to store a value other than null causes a ViewConstraintException to be thrown.

    • viewReverse

      default View viewReverse()
      Returns a view, backed by this one, whose natural order is reversed.

    • viewUnmodifiable

      default View viewUnmodifiable()
      Returns a view, backed by this one, whose entries cannot be modified. Any attempt to do so causes an UnmodifiableViewException to be thrown.

    • isUnmodifiable

      boolean isUnmodifiable()
      Returns true if any attempt to modify this view causes an UnmodifiableViewException to be thrown.

    • isModifyAtomic

      default boolean isModifyAtomic()
      Returns true if the value-modifying methods of this view are atomic, even when not using transactions.