internal void FireNodeOperation(IRBNode node, NodeOperation operation) { if (NodeOperation != null) { NodeOperation(node, operation); } }
/// <summary> /// Walk the logical tree, and perform an operation on all nodes and children of nodes. /// This is slightly more complex than it might otherwise be because it makes no assumptions /// that the Logical Tree is strongly typed. It is the responsibility of the operation to make sure /// that it can handle the node it receives. /// </summary> /// <param name="node"></param> /// <param name="operation"></param> private void WalkLogicalTree(object node, NodeOperation operation) { if (node != null) { operation(node); } DependencyObject treeNode = node as DependencyObject; if (treeNode == null) { return; } IEnumerator e = LogicalTreeHelper.GetChildren(treeNode).GetEnumerator(); if (e == null) { return; } while (e.MoveNext()) { WalkLogicalTree(e.Current, operation); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldHandleIndexDropConcurrentlyWithOperation(NodeOperation operation) throws Throwable private void ShouldHandleIndexDropConcurrentlyWithOperation(NodeOperation operation) { // given long[] nodes = CreateNodes(); IndexDefinition indexDefinition = CreateIndex(); // when Race race = new Race(); race.AddContestant(() => { using (Transaction tx = Db.beginTx()) { indexDefinition.Drop(); tx.Success(); } }, 1); for (int i = 0; i < NODES; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long nodeId = nodes[i]; long nodeId = nodes[i]; race.AddContestant(throwing(() => { using (Transaction tx = Db.beginTx()) { operation.Run(nodeId); tx.Success(); } })); } // then race.Go(); }
public NodeOperationDetails(NodeOperation operation, INode map, Node node) { Operation = operation; Map = map; Nodes = new [] {node}; OldLocation = node.Location; }
internal NodeDictionary(int index, bool hasMine, int mineCount, NodeOperation op) { Index = index; HasMine = hasMine; MineCount = (byte)mineCount; State = _operationToStateMap[op]; }
public NodeOperationDetails(NodeOperation operation, INode map, Node node) { Operation = operation; Map = map; Nodes = new [] { node }; OldLocation = node.Location; }
/// <summary> /// it is maintaind the current operation type is remove and newOp operation type is insert /// </summary> /// <param name="current"></param> /// <param name="currentB"></param> /// <param name="newOp"></param> /// <returns></returns> private bool InsertOnRemoveHandler(ref NodeOperation current, ref NodeOperation currentB, NodeOperation newOp) { if (currentB == null) // insert done on remove, change it to set { if (current.Count == 1) // if there is only one remove { current.Operation = OperationType.Set; current.Value = newOp.Value; } else { current.Count--; //decrease the remove count currentB = new NodeOperation(); // and append a new set opertaion currentB.Operation = OperationType.Set; currentB.Value = newOp.Value; } return(true); // the insert operation is assimilated into the node } //the only options here is that currentB operation type is set (other operationB are not allowed, it always remove and set if (currentB.Operation != OperationType.Set) { throw new Exception(); } return(false); // the insert should push this right and continue }
/*####################################################################*/ /* DFS Operations */ /*####################################################################*/ public void DfsOperationChildren(NodeOperation <T> operation) { foreach (var child in Children) { child.DfsOperation(operation); } }
/// <summary> /// handles appending of a remove operation to the node /// </summary> /// <param name="current"></param> /// <param name="currentB"></param> /// <param name="newOp"></param> /// <returns></returns> private bool RemoveHandler(ref NodeOperation current, ref NodeOperation currentB, NodeOperation newOp) { if (current == null) // this is no operation node , push it right and continue { current = newOp; return(true); // the remove operation is assimilated into the node } if (current.Operation == OperationType.Insert) { if (newOp.Count != 1) { throw new InvalidOperationException(); } current = null; // this is a noop , insert and then remove at the same index currentB = null; return(true); // the remove operation is assimilated into the node } if (current.Operation == OperationType.Set) { if (newOp.Count != 1) { throw new InvalidOperationException(); } // setting a value and the removeing that index , it should be overriden current = newOp; return(true); // the remove operation is assimilated into the node } //current operation is remove. currentB = null; // regardles of the value of currentB , the set operation that it might contain is removed //no addiational operations just add one to the remove count current.Count += newOp.Count; return(true); // the remove operation is assimilated into the node }
/// <summary> /// handles appending of a set operation to the node /// </summary> /// <param name="current"></param> /// <param name="currentB"></param> /// <param name="newOp"></param> /// <returns></returns> private bool SetHandler(ref NodeOperation current, ref NodeOperation currentB, NodeOperation newOp) { if (current == null) // this is no operation node , apply the set operation { current = newOp; return(true); // the set operation is assimilated into the node } if (current.Operation == OperationType.Insert || current.Operation == OperationType.Set) // this means currentB is false (because it is only allowed when current is remove and currentb is set { current.Value = newOp.Value; // just use the new value instead return(true); } //current operation is remove if (currentB == null) // this should be removeSet node then , if there is no set it is created { currentB = newOp; } else { if (currentB.Operation != OperationType.Set) { throw new InvalidOperationException(); } currentB.Value = newOp.Value; } return(true); // the set operation is assimilated into the node }
internal BenchmarkNodeWithoutIn(BenchmarkNodeWithoutIn node, NodeOperation op) { Index = node.Index; HasMine = node.HasMine; MineCount = node.MineCount; State = _operationToStateMap[op]; }
public void TestMultipleAdd() { double a = 5.0; INode tree = new NodeOperation(new NodeOperation(new NodeValue(a), new NodeValue(a), OperationType.ADDITION), new NodeOperation(new NodeValue(a), new NodeValue(a), OperationType.ADDITION), OperationType.ADDITION); Assert.AreEqual(20.0, tree.GetResult(), 0.001, "Tripple add doesn't work"); }
public Turn(int nodeIndex, NodeOperation operation) { Debug.Assert(nodeIndex >= 0); Debug.Assert(Enum.IsDefined(operation)); NodeIndex = nodeIndex; Operation = operation; }
public void TestSub() { double a = 5.0; double b = 3.5; INode tree = new NodeOperation(new NodeValue(a), new NodeValue(b), OperationType.SUBSTRACTION); Assert.AreEqual(1.5, tree.GetResult(), 0.001, "Subtraction does not work."); }
public void TestMul() { double a = 5.0; double b = 2.0; INode tree = new NodeOperation(new NodeValue(a), new NodeValue(b), OperationType.MULTIPLICATION); Assert.AreEqual(10, tree.GetResult(), 0.001, "Multiply does not work."); }
public void TestAdd() { double a = 5.0; double b = 3.5; INode tree = new NodeOperation(new NodeValue(a), new NodeValue(b), OperationType.ADDITION); Assert.AreEqual(8.5, tree.GetResult(), 0.001, "Add does not work."); }
public void TestMultipleSub() { double a = 20.0; double b = 5.0; INode tree = new NodeOperation(new NodeValue(a), new NodeOperation(new NodeValue(b), new NodeValue(b), OperationType.ADDITION), OperationType.SUBSTRACTION); Assert.AreEqual(10, tree.GetResult(), 0.001, "Something went wrong."); }
public void Commit() { NodeOperation.Commit(); foreach (var edgeEdit in EdgeOperations) { edgeEdit.Commit(); } }
public void TestMultipleSub_Mul() { double a = 10.0; double b = 2.0; INode tree = new NodeOperation(new NodeValue(a), new NodeOperation(new NodeValue(b), new NodeValue(b), OperationType.MULTIPLICATION), OperationType.SUBSTRACTION); Assert.AreEqual(6.0, tree.GetResult(), 0.001, "Multiple multiplication + substraction doesn't work"); }
public void TestMultipleSub_Div() { double a = 10.0; double b = 5.0; INode tree = new NodeOperation(new NodeValue(a), new NodeOperation(new NodeValue(b), new NodeValue(b), OperationType.DIVISION), OperationType.SUBSTRACTION); Assert.AreEqual(9.0, tree.GetResult(), 0.001, "Multiple division + substraction doesn't work"); }
public void TestMultipleAdd_Div_zero() { double a = 0; double b = 5; INode tree = new NodeOperation(new NodeOperation(new NodeValue(a), new NodeValue(b), OperationType.DIVISION), new NodeValue(b), OperationType.ADDITION); Assert.AreEqual(5.0, tree.GetResult(), 0.001, "Multiple addition + division with zero doesn't work"); }
public void TestPower() { double a = 5; double b = 2; INode tree = new NodeOperation(new NodeValue(a), new NodeValue(b), OperationType.POWER); Assert.AreEqual(25.0, tree.GetResult(), 0.001, "Multiple addition + division with zero doesn't work"); }
public void TestMultipleAdd_Mul() { double a = 5.0; double b = 2.0; INode tree = new NodeOperation(new NodeValue(a), new NodeOperation(new NodeValue(b), new NodeValue(b), OperationType.MULTIPLICATION), OperationType.ADDITION); Assert.AreEqual(9.0, tree.GetResult(), 0.001, "Multiple multiplication + addition doesn't work"); }
public void TestMultipleAdd_Div() { double a = 5.0; double b = 6.0; double c = 3.0; INode tree = new NodeOperation(new NodeValue(a), new NodeOperation(new NodeValue(b), new NodeValue(c), OperationType.DIVISION), OperationType.ADDITION); Assert.AreEqual(7.0, tree.GetResult(), 0.001, "Multiple division + addition doesn't work"); }
public void DeleteWith(Node n) { Key = n.Key; if (n.KeyModifier != 0 || KeyModifier != 0) { throw new InvalidOperationException(); } mOperationA = n.mOperationA; mOperationB = n.mOperationB; }
public void TestMultipleDiv() { double a = 100.0; double b = 2.0; double c = 5.0; NodeOperation p1 = new NodeOperation(new NodeValue(a), new NodeValue(b), OperationType.DIVISION); NodeOperation p2 = new NodeOperation(new NodeValue(p1.GetResult()), new NodeValue(b), OperationType.DIVISION); INode tree = new NodeOperation(new NodeValue(p2.GetResult()), new NodeValue(c), OperationType.DIVISION); Assert.AreEqual(5.0, tree.GetResult(), 0.001, "Multiple division doesn't work"); }
public void TestMultipleMul() { double a = 2.0; double b = 3.0; NodeOperation p1 = new NodeOperation(new NodeValue(a), new NodeValue(a), OperationType.MULTIPLICATION); NodeOperation p2 = new NodeOperation(new NodeValue(p1.GetResult()), new NodeValue(b), OperationType.MULTIPLICATION); INode tree = new NodeOperation(new NodeValue(p2.GetResult()), new NodeValue(b), OperationType.MULTIPLICATION); Assert.AreEqual(36.0, tree.GetResult(), 0.001, "Multiple multiplication doesn't work"); }
public NodeOperationDetails(NodeOperation operation, INode map, IEnumerable<Node> nodes, IEnumerable<Relationship> relationships) { Operation = operation; Map = map; Nodes = nodes; Relationships = relationships; if (OldLocation == null) { OldLocation = Nodes.Select(q => q.Location).OrderBy(q => q.X).ThenBy(q => q.Y).FirstOrDefault(); } }
public NodeOperationDetails(NodeOperation operation, INode map, IEnumerable <Node> nodes, IEnumerable <Relationship> relationships) { Operation = operation; Map = map; Nodes = nodes; Relationships = relationships; if (OldLocation == null) { OldLocation = Nodes.Select(q => q.Location).OrderBy(q => q.X).ThenBy(q => q.Y).FirstOrDefault(); } }
public Node(int key, T value, Node left, Node right, Node parent, NodeColor color, OperationType op) { Key = key; Parent = parent; Left = left; Right = right; Color = color; mOperationA = new NodeOperation(); mOperationA.Count = 1; mOperationA.Operation = op; mOperationA.Value = value; }
internal NodeSwitch(int index, bool hasMine, int mineCount, NodeOperation op) { Index = index; HasMine = hasMine; MineCount = (byte)mineCount; State = op switch { NodeOperation.Reveal => NodeState.Revealed, NodeOperation.Flag => NodeState.Flagged, _ => NodeState.Hidden, }; }
/// <summary> /// handles appending of an insert operation to the node /// </summary> /// <param name="current"></param> /// <param name="currentB"></param> /// <param name="newOp"></param> /// <returns></returns> private bool InsertHandler(ref NodeOperation current, ref NodeOperation currentB, NodeOperation newOp) { if (current == null) // this is no operation node , push it right and continue { return(false); } if (current.Operation == OperationType.Remove) { return(InsertOnRemoveHandler(ref current, ref currentB, newOp)); } return(false); // both insert and set require pushing this node right and continuing with insertion }