public LRUCache(int capacity) { _capacity = capacity; _nodes = new Dictionary <int, MutableNode>(capacity); First = new MutableNode(int.MinValue, int.MinValue); Last = new MutableNode(int.MinValue, int.MinValue); }
private void MoveToFront(MutableNode node) { if (node == First.Next) { return; } node.Previous.Next = node.Next; node.Next.Previous = node.Previous; node.Previous = First; node.Next = First.Next; node.Next.Previous = node; First.Next = node; }
public void MutableNode_fails_on_replacing_unknown_child() { // ARRANGE // none of the child nodes are added to the root node. var child = new MutableNode <string, int>("a"); var node = MutableNode <string, int> .CreateRoot(); var secondChild = new MutableNode <string, int>("a"); // ACT var result = Assert.Throws <InvalidOperationException>(() => node.ReplaceChild(child, secondChild)); // ASSERT Assert.Equal("The node (id=a) doesn't substutite any of the existing child nodes", result.Message); Assert.False(node.HasChildNodes); }
public void MutableNode_removes_child_from_current_instance() { // ARRANGE var child = new MutableNode <string, int>("a"); var node = MutableNode <string, int> .CreateRoot().AddChild(child); // ACT var result = node.RemoveChild(child); // ASSERT Assert.Same(node, result); Assert.False(node.HasChildNodes); Assert.False(result.ChildNodes.Any()); var(found, addedChild) = node.TryGetChildNode("a"); Assert.False(found); }
public void MutableNode_adds_child_to_current_instance() { // ARRANGE var child = new MutableNode <string, int>("a"); var node = MutableNode <string, int> .CreateRoot(); // ACT var result = node.AddChild(child); // ASSERT Assert.Same(node, result); Assert.True(node.HasChildNodes); Assert.Same(child, result.ChildNodes.Single()); var(found, addedChild) = node.TryGetChildNode("a"); Assert.True(found); Assert.Same(child, addedChild); }
public bool RemoveNode(HierarchyPath <TKey> path, bool recurse) { if (path.IsRoot) { if (!recurse && this.rootNode.HasChildNodes) { // is recurse is not set, the root node can be exhanged if the root has no child nodes return(false); } this.rootNode = MutableNode <TKey, TValue> .CreateRoot(); return(true); } else { // this isn't a special case. // use the hierachy writer for inner nodes var writer = new RemoveNodeHierarchyWriter <TKey, MutableNode <TKey, TValue> >(); var result = writer.RemoveNode(this.rootNode, path, recurse, out var nodeWasRemoved); return(nodeWasRemoved); } }
public void MutableNode_fails_on_Replace_if_keys_are_different() { // ARRANGE var child = new MutableNode <string, int>("a"); var node = MutableNode <string, int> .CreateRoot().AddChild(child); var secondChild = new MutableNode <string, int>("b"); // ACT var result = Assert.Throws <InvalidOperationException>(() => node.ReplaceChild(child, secondChild)); // ASSERT Assert.Equal("Key of child to replace (key='a') and new child (key='b') must be equal", result.Message); Assert.True(node.HasChildNodes); Assert.Same(child, node.ChildNodes.Single()); var(found, addedChild) = node.TryGetChildNode("a"); Assert.True(found); Assert.Same(child, addedChild); }
private MutableHierarchy(bool pruneOnUnsetValue) { this.rootNode = MutableNode <TKey, TValue> .CreateRoot(); this.pruneOnUnsetValue = pruneOnUnsetValue; }