internal ImMapTree(ImMapData <V> data, ImMap <V> left, ImMap <V> right, int height)
{
Data = data;
Left = left;
Right = right;
TreeHeight = height;
}
private void AvlTreeAction(Type key)
{
if (imMap.GetValueOrDefault(key) is null)
{
imMap = imMap.AddOrUpdate(key, null);
}
}
public static State UpdateRadioButtons(ImMap <string, int> radioButtons, State state)
{
var uiState = GetUIState(state);
uiState.RadioButtons = radioButtons;
return(UpdateUIState(uiState, state));
}
public static bool TryFind <V>(this ImMap <V> map, int key, out V value)
{
int mapKey;
while (map is ImMapTree <V> mapTree)
{
mapKey = mapTree.Data.Key;
if (key < mapKey)
{
map = mapTree.Left;
}
else if (key > mapKey)
{
map = mapTree.Right;
}
else
{
value = mapTree.Data.Value;
return(true);
}
}
if (map is ImMapData <V> leaf && leaf.Key == key)
{
value = leaf.Value;
return(true);
}
value = default;
return(false);
}
internal ImMapTree(ImMapData <V> data, ImMapTree <V> left, ImMapTree <V> right)
{
Data = data;
Left = left;
Right = right;
TreeHeight = left.TreeHeight > right.TreeHeight ? left.TreeHeight + 1 : right.TreeHeight + 1;
}
internal ImMapTree(ImMapData <V> data, ImMapData <V> leftData, ImMapData <V> rightData)
{
Data = data;
Left = leftData;
Right = rightData;
TreeHeight = 2;
}
public static V GetValueOrDefault <V>(this ImMap <V> map, int key, V defaultValue)
{
while (map.Height != 0 && map.Key != key)
{
map = key < map.Key ? map.Left : map.Right;
}
return(map.Height != 0 ? map.Value : defaultValue);
}
public static V GetValueOrDefault <V>(this ImMap <V> map, int key)
{
while (map.Height != 0 && map.Key != key)
{
map = key < map.Key ? map.Left : map.Right;
}
return(map.Value); // that's fine to return the value without check, because for we have a default value in empty map
}
internal ImMapTree(ImMapData <V> data, ImMap <V> left, int rightHeight, ImMap <V> right)
{
Data = data;
Left = left;
Right = right;
var leftHeight = left.Height;
TreeHeight = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
public void Setup()
{
lock (dictionaryWithLock)
{
foreach (var type in Classes.Types)
{
dictionary[type] = new object();
dictionaryWithLock[type] = new object();
concurrentDictionary[type] = new object();
hashArrayMap.AddIfNotExist(type, new object());
imMap = imMap.AddOrUpdate(type, new object());
}
}
}
public static ImMap <V> AddOrUpdate <V>(this ImMap <V> map, int key, V value)
{
if (map is ImMapTree <V> tree)
{
return(key == tree.Data.Key
? new ImMapTree <V>(new ImMapData <V>(key, value), tree.Left, tree.Right, tree.TreeHeight)
: tree.AddOrUpdateLeftOrRight(key, value));
}
if (map is ImMapBranch <V> treeLeaf)
{
if (key > treeLeaf.Data.Key)
{
return(treeLeaf.IsLeftOriented
? new ImMapTree <V>(treeLeaf.Data, treeLeaf.LeftOrRight, new ImMapData <V>(key, value))
: key <treeLeaf.LeftOrRight.Key // rotate if right
?new ImMapTree <V>(new ImMapData <V>(key, value), treeLeaf.Data, treeLeaf.LeftOrRight)
: key> treeLeaf.LeftOrRight.Key
? new ImMapTree <V>(treeLeaf.LeftOrRight, treeLeaf.Data, new ImMapData <V>(key, value))
: (ImMap <V>) new ImMapBranch <V>(treeLeaf.Data, new ImMapData <V>(key, value)));
}
if (key < treeLeaf.Data.Key)
{
return(treeLeaf.IsRightOriented
? new ImMapTree <V>(treeLeaf.Data, new ImMapData <V>(key, value), treeLeaf.LeftOrRight)
: key > treeLeaf.LeftOrRight.Key // rotate if left
? new ImMapTree <V>(new ImMapData <V>(key, value), treeLeaf.LeftOrRight, treeLeaf.Data)
: key < treeLeaf.LeftOrRight.Key
? new ImMapTree <V>(treeLeaf.LeftOrRight, new ImMapData <V>(key, value), treeLeaf.Data)
: (ImMap <V>) new ImMapBranch <V>(treeLeaf.Data, new ImMapData <V>(key, value)));
}
return(new ImMapBranch <V>(new ImMapData <V>(key, value), treeLeaf.LeftOrRight));
}
if (map is ImMapData <V> data)
{
return(key > data.Key
? new ImMapBranch <V>(data, new ImMapData <V>(key, value))
: key < data.Key
? new ImMapBranch <V>(new ImMapData <V>(key, value), data)
: (ImMap <V>) new ImMapData <V>(key, value));
}
return(new ImMapData <V>(key, value));
}
public static bool TryFind <V>(this ImMap <V> map, int key, out V value)
{
while (map.Height != 0)
{
if (key < map.Key)
{
map = map.Left;
}
else if (key > map.Key)
{
map = map.Right;
}
else
{
break;
}
}
value = map.Value;
return(map.Height != 0);
}
public BenchmarkTest()
{
NErrorLog.Enabled = true;
NatashaInitializer.InitializeAndPreheating();
model = new TestModel();
_imMap = ImMap <string> .Empty;
_imHashMap = ImHashMap <string, string> .Empty;
FuzzyHandler = model.Model1.FuzzyTree();
HashHandler = model.Model1.HashTree();
PrecisionHandler = model.Model1.PrecisioTree();
DictHandler = model.Model1;
Dictionary <int, string> hashDict = new();
foreach (var item in model.Model1)
{
_imHashMap = _imHashMap.AddOrUpdate(item.Key, item.Value);
_imMap = _imMap.AddOrUpdate(Int32.Parse(item.Key), item.Value);
hashDict[Int32.Parse(item.Key)] = item.Value;
}
HashCodePrecisionHandler = hashDict.CustomerTree(item => item.ToString());
ConDictHandler = new ConcurrentDictionary <string, string>(model.Model1);
ReadonlyDictHandler = ImmutableDictionary.CreateRange(DictHandler);
}
public UIState(List <PopupType> popups, ImMap <string, int> radioButtons)
{
Popups = popups;
RadioButtons = radioButtons;
}