BijectionMap

BijectionMap<L, R> is a map that holds 1:1 correspondence between left and right sides.

var map = new BijectionMap<string, int>();

BijectionMap.Create(leftType, rightType) creates with type arguments.

var map =
    (BijectionMap<string, int>)
    BijectionMap.Create(typeof(string), typeof(int));

BijectionMap can be constructed with explicit comparers.

IEqualityComparer<string> leftComparer = StringComparer.InvariantCultureIgnoreCase;
IEqualityComparer<int> rightComparer = EqualityComparer<int>.Default;
var map = new BijectionMap<string, int>(leftComparer, rightComparer);

IEqualityComparer<string> leftComparer = StringComparer.InvariantCultureIgnoreCase;
IEqualityComparer<int> rightComparer = EqualityComparer<int>.Default;
var map = BijectionMap.Create(typeof(string), typeof(int), leftComparer, rightComparer);

BijectionMap can be constructed with IEnumerable<KeyValuePair<L, R>> initialization values.

var dictionary = new Dictionary<string, int> { { "Hello", 123 } };
var map = new BijectionMap<string, int>(dictionary);

.AddAll(IEnumerable<KeyValuePair<L, R>>) adds from a source.

var dictionary = new Dictionary<string, int> { { "Hello", 123 } };
var map = new BijectionMap<string, int>()
    .AddAll(dictionary);

.Put(L, R) puts a value pair to the map.

var map = new BijectionMap<string, int>();
map.Put("A", 1);
map.Put("B", 2);
map.Put("C", 3);

.GetLeft(), .TryGetLeft(), .GetRight(), .TryGetRight() and R this[L] returns correlated value from the other side.

int x = map["A"];
string y = map.GetLeft(2);
int z = map.GetRight("B");
if (map.TryGetRight("C", out int value0)) WriteLine(value0); // 3
if (map.TryGetLeft(2, out string? value1)) WriteLine(value1); // "B"

.SetReadOnly() extension method of IReadOnly locks dictionary.

map.SetReadOnly();

After locking write throws InvalidOperationException.

// Write
try
{
    map.Put("Key3", 99);
}
catch (InvalidOperationException)
{
}

.Contains(L, R), .ContainsLeft(L), .ContainsRight(R) tests whether specific value exists in the map.

WriteLine(map.Contains("A", 1)); // True
WriteLine(map.Contains("A", 2)); // False
WriteLine(map.ContainsLeft("A")); // True
WriteLine(map.ContainsRight(3)); // True

.RemoveWithLeft(L) and .RemoveWithRight(R) removes a pair with left and right keys.

map.RemoveWithLeft("A");
map.RemoveWithRight(2);

.RetainAllLeft(IEnumerable<L>) and .RetainAllRight(IEnumerable<R>) retains values.

map.RetainAllLeft(new string[] { "B", "C" });
map.RetainAllRight(new int[] { 2, 3 });

.GetRightSet(), .GetLeftSet(), .GetLeftToRightDictionary() and .GetRightToLeftDictionary() returns internal maps.

ICollection<int> rightSet = map.GetRightSet();
ICollection<string> leftSet = map.GetLeftSet();
IDictionary<string, int> rightMap = map.GetLeftToRightDictionary();
IDictionary<int, string> leftMap = map.GetRightToLeftDictionary();

Full Example

Full example

using System;
using System.Collections.Generic;
using Avalanche.Utilities;
using static System.Console;

public class bijectionmap
{
    public static void Run()
    {
        {
            // <01>
            var map = new BijectionMap<string, int>();
            // </01>
        }
        {
            // <02>
            var map =
                (BijectionMap<string, int>)
                BijectionMap.Create(typeof(string), typeof(int));
            // </02>
        }

        {
            // <03>
            IEqualityComparer<string> leftComparer = StringComparer.InvariantCultureIgnoreCase;
            IEqualityComparer<int> rightComparer = EqualityComparer<int>.Default;
            var map = new BijectionMap<string, int>(leftComparer, rightComparer);
            // </03>
        }

        {
            // <04>
            IEqualityComparer<string> leftComparer = StringComparer.InvariantCultureIgnoreCase;
            IEqualityComparer<int> rightComparer = EqualityComparer<int>.Default;
            var map = BijectionMap.Create(typeof(string), typeof(int), leftComparer, rightComparer);
            // </04>
        }
        {
            // <05>
            var dictionary = new Dictionary<string, int> { { "Hello", 123 } };
            var map = new BijectionMap<string, int>(dictionary);
            // </05>
        }
        {
            // <06>
            var dictionary = new Dictionary<string, int> { { "Hello", 123 } };
            var map = new BijectionMap<string, int>()
                .AddAll(dictionary);
            // </06>
        }

        {
            // <07>
            var map = new BijectionMap<string, int>();
            map.Put("A", 1);
            map.Put("B", 2);
            map.Put("C", 3);
            // </07>

            // <08>
            int x = map["A"];
            string y = map.GetLeft(2);
            int z = map.GetRight("B");
            if (map.TryGetRight("C", out int value0)) WriteLine(value0); // 3
            if (map.TryGetLeft(2, out string? value1)) WriteLine(value1); // "B"
            // </08>

            // <09>
            map.SetReadOnly();
            // </09>

            // <10>
            // Write
            try
            {
                map.Put("Key3", 99);
            }
            catch (InvalidOperationException)
            {
            }
            // </10>
        }

        {
            var map = new BijectionMap<string, int>();
            map.Put("A", 1);
            map.Put("B", 2);
            map.Put("C", 3);
            // <11>
            WriteLine(map.Contains("A", 1)); // True
            WriteLine(map.Contains("A", 2)); // False
            WriteLine(map.ContainsLeft("A")); // True
            WriteLine(map.ContainsRight(3)); // True
            // </11>
        }

        {
            var map = new BijectionMap<string, int>();
            map.Put("A", 1);
            map.Put("B", 2);
            map.Put("C", 3);
            // <12>
            map.RemoveWithLeft("A");
            map.RemoveWithRight(2);
            // </12>
        }

        {
            var map = new BijectionMap<string, int>();
            map.Put("A", 1);
            map.Put("B", 2);
            map.Put("C", 3);
            // <13>
            map.RetainAllLeft(new string[] { "B", "C" });
            map.RetainAllRight(new int[] { 2, 3 });
            // </13>
            foreach (var pair in map) WriteLine(pair);
        }

        {
            var map = new BijectionMap<string, int>();
            map.Put("A", 1);
            map.Put("B", 2);
            map.Put("C", 3);
            // <14>
            ICollection<int> rightSet = map.GetRightSet();
            ICollection<string> leftSet = map.GetLeftSet();
            IDictionary<string, int> rightMap = map.GetLeftToRightDictionary();
            IDictionary<int, string> leftMap = map.GetRightToLeftDictionary();
            // </14>
        }
    }
}