Module fr.dufrenoy.util

Package fr.dufrenoy.util

Interface SymmetricMap<K,V>

Type Parameters:

K - the type of keys

V - the type of values

All Superinterfaces:

Map<K,V>

All Known Implementing Classes:

SynchronizedSymmetricMap, UnsynchronizedSymmetricMap

public interface SymmetricMap<K,V>
extends Map<K,V>

A bijective map where both keys and values are unique.

In addition to the standard Map contract, this interface exposes symmetric operations — lookup, removal, and insertion — that work equally in both directions:

• Map.get(Object) — retrieve a value by key (inherited from Map)
• getKey(Object) — retrieve a key by value
• Map.remove(Object) — remove an entry by key (inherited from Map)
• removeByValue(Object) — remove an entry by value
• Map.put(Object, Object) — insert permissively (inherited from Map)
• safePut(Object, Object) — insert strictly

Because values are unique by definition, values() returns a Set<V> rather than a Collection<V>.

Two implementations are provided:

• UnsynchronizedSymmetricMap — not thread-safe.
• SynchronizedSymmetricMap — thread-safe, backed by a ReentrantReadWriteLock.

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K extends Object,V extends Object>

Method Summary

Modifier and Type	Method	Description
Optional<K>	getKey(Object value)	Returns the key associated with the given value, or empty if not found.
SymmetricMap<V,K>	inverse()	Returns an independent copy of this map with keys and values swapped.
Optional<K>	removeByValue(Object value)	Removes the entry associated with the given value, if present.
void	safePut(K key, V value)	Associates the given key with the given value, throwing an exception if the key or value already exists in this map.
Set<V>	values()	Returns a Set view of the values contained in this map.

Methods inherited from interface java.util.Map

clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, size

Method Detail

getKey

Optional<K> getKey(Object value)

Returns the key associated with the given value, or empty if not found.

Parameters:

value - the value to look up

Returns:

an Optional containing the key associated with value, or empty if not found

safePut

void safePut(K key,
             V value)

Associates the given key with the given value, throwing an exception if the key or value already exists in this map.

Use Map.put(Object, Object) for a permissive insertion that silently removes conflicting entries.

Parameters:

key - the key

value - the value

Throws:

IllegalArgumentException - if the key or value already exists

removeByValue

Optional<K> removeByValue(Object value)

Removes the entry associated with the given value, if present. Symmetric to Map.remove(Object) which removes by key.

Parameters:

value - the value whose entry is to be removed

Returns:

an Optional containing the key that was associated with value, or empty if not found

inverse

SymmetricMap<V,K> inverse()

Returns an independent copy of this map with keys and values swapped. Modifications to the returned map do not affect this map, and vice versa.

The returned map is of the same type as this map: an UnsynchronizedSymmetricMap returns an UnsynchronizedSymmetricMap, and a SynchronizedSymmetricMap returns a SynchronizedSymmetricMap.

Returns:

a new SymmetricMap<V, K> with all entries inverted

values

Set<V> values()

Returns a Set view of the values contained in this map.

This method narrows the return type of Map.values() from Collection to Set, which is valid since values in a bijective map are unique by definition.

The returned set is a live view of the map: changes to the map are reflected in the set, and vice versa.

Specified by:

values in interface Map<K,V>

Returns:

a set view of the values contained in this map