Add TwoWayMap class

[aleclarson]

The TwoWayMap class extends the built-in Map class to provide bi-directional key-value lookups. It allows efficient retrieval of values by keys and keys by values.

Functionality

• Extends the standard Map class, inheriting its core functionality
• Maintains an additional internal map for reverse lookups
• Provides methods for bi-directional access:
  • Standard Map methods (get, set, has, delete, etc.) for forward lookups
  • New methods (getKey, hasValue) for reverse lookups
• Automatically keeps forward and reverse mappings in sync

Implementation

• The class extends Map<K, V> for the forward map
• Uses a private Map<V, K> for the backward map
• Overrides set(), delete(), and clear() to maintain consistency between maps
• Adds getKey() and hasValue() methods for reverse lookups

class TwoWayMap<K, V> extends Map<K, V> {
    private byValue = new Map<V, K>();

    constructor(entries?: readonly (readonly [K, V])[]) {
        super();
        if (entries) {
            entries.forEach(([key, value]) => this.set(key, value));
        }
    }

    set(key: K, value: V): this {
        // Remove old value->key mapping if it exists
        if (this.has(key)) {
            this.byValue.delete(super.get(key)!);
        }

        // Update both maps
        super.set(key, value);
        this.byValue.set(value, key);
        return this;
    }

    delete(key: K): boolean {
        if (this.has(key)) {
            const value = super.get(key)!;
            this.byValue.delete(value);
            return super.delete(key);
        }
        return false;
    }

    clear(): void {
        super.clear();
        this.byValue.clear();
    }

    getKey(value: V): K | undefined {
        return this.byValue.get(value);
    }

    hasValue(value: V): boolean {
        return this.byValue.has(value);
    }
}

Limitations

1. One-to-One Mapping: Each key must have a unique value and vice versa. Adding a new key-value pair will overwrite any existing entries with the same key or value.
2. Memory Usage: Stores each key-value pair twice, potentially increasing memory usage compared to a standard Map.

Use Cases

Ideal for scenarios requiring frequent lookups in both directions, such as:

• Caching with bi-directional access needs
• Managing relationships between two sets of identifiers
• Implementing simple graph-like structures