public void Run() { _logger.Information("Running spv wallet"); var registry = new Registry(); registry.Schedule(() => { if (_lastHeight != CurrentHeight) { _logger.Information($"Connected nodes -> {ConnectedNodes.Count()}"); _logger.Information($"Height -> {CurrentHeight}"); _lastHeight = CurrentHeight; _logger.Information($"Wallet Balance -> {GetBalance()}"); SaveAsync(); _logger.Information("******************************************"); } }).ToRunNow().AndEvery(10).Seconds(); JobManager.Initialize(registry); JobManager.Start(); //Console.CancelKeyPress += (sender, eArgs) => { // _quitEvent.Set(); // eArgs.Cancel = true; //}; _wallet.Tracker.NewOperation += Tracker_NewOperation; // kick off asynchronous stuff _quitEvent.WaitOne(); }
// Description: Adds a link between every node in order that they were selected // PRE: N/A // POST: There exists a link between every node selected (n-1 links) public void Link() { // Spawn a new link where the origin is the first index, // and the secondary node is the second node if (selectedNodes.Count >= 2) { for (int i = 1; i < selectedNodes.Count; i++) { // Keys for our hash table, connectedNodes ConnectedNodes nodePair = new ConnectedNodes(selectedNodes[i - 1], selectedNodes[i]); ConnectedNodes reversedPair = new ConnectedNodes(selectedNodes[i], selectedNodes[i - 1]); if (!connectedNodes.Contains(nodePair)) { if (connectedNodes.Contains(reversedPair)) { Destroy((GameObject)connectedNodes[reversedPair]); connectedNodes.Remove(reversedPair); UpdateNumberOfNodeConnections(reversedPair, false); } GameObject newLink = CreateLink(nodePair); connectedNodes.Add(nodePair, newLink); UpdateNumberOfNodeConnections(nodePair, true); } } this.ClearSelection(); } UpdateLinkInspector(); }
// Description: Updates the number of connections in the BuildViewNode's information // PRE: The given nodepair has an origin and a destination nodes // POST: The number of connections for these nodes has been updated private void UpdateNumberOfNodeConnections(ConnectedNodes nodePair, bool isAddingOneConnection) { int i = isAddingOneConnection ? 1 : 0; nodePair.origin.NumberOfConnections += 2 * i - 1; nodePair.destination.NumberOfConnections += 2 * i - 1; }
protected override void OnDragFinish() { ExecuteNode hoveredNode = (SelectionManager.Instance.HoverNode as ExecuteNode); if (!hoveredNode) { Destroy(currentGameObject); currentDraggingLine = null; return; } if (hoveredNode != this) { if (hoveredNode.IsInputNode != IsInputNode) { NodeConnection <ExecuteNode> nodeConnection = new NodeConnectionBuilder <ExecuteNode>() .SetNodes(this, hoveredNode) .SetConnectionLine(currentDraggingLine) .Build(); ConnectedNodes.Add(nodeConnection.Cast <ConnectedNode>()); hoveredNode.ConnectedNodes.Add(nodeConnection.Cast <ConnectedNode>()); RegisterExecNodes(nodeConnection); nodeConnection.UpdateLine(); currentGameObject = null; return; } } Destroy(currentGameObject); currentDraggingLine = null; }
public void Connect(LocationNode n) { if (!ConnectedNodes.Contains(n)) { ConnectedNodes.Add(n); } }
/// <summary>Creates a deep copy of this device.</summary> /// <returns></returns> public virtual ICircuitDefinitionDevice Clone() { var circuitDefinitionDevice = (CircuitDefinitionDevice)MemberwiseClone(); circuitDefinitionDevice.ConnectedNodes = ConnectedNodes.Clone(); return(circuitDefinitionDevice); }
/// <summary> /// Remove this object from all connected anchors /// </summary> public void ClearNodes() { foreach (Node node in ConnectedNodes) { node.ConnectedElements.Remove(this); // Remove the anchor from the node } ConnectedNodes.Clear(); }
void node_StateChanged(Node node, NodeState oldState) { if (node.State == NodeState.Disconnecting || node.State == NodeState.Failed || node.State == NodeState.Offline) { ConnectedNodes.Remove(node); } }
// Description: Creates the Link object to be placed between two nodes // PRE: nodePair contains two nodes // POST: There exists a link between each of the nodes in nodePair private GameObject CreateLink(ConnectedNodes nodePair) { GameObject newLink = Instantiate(LinkPrefab); newLink.tag = "Link"; BuildViewLink linkScript = newLink.GetComponent <BuildViewLink>(); linkScript.origin = nodePair.origin; linkScript.destination = nodePair.destination; return(newLink); }
/// <summary> /// Asynchronously create a new set of nodes /// </summary> public void Purge(string reason) { Task.Factory.StartNew(() => { var initialNodes = ConnectedNodes.ToDictionary(n => n); while (!_disconnect.IsCancellationRequested && initialNodes.Count != 0) { var node = initialNodes.First(); node.Value.Disconnect(reason); initialNodes.Remove(node.Value); _disconnect.Token.WaitHandle.WaitOne(5000); } }); }
/// <summary> /// Splits this island across the /// specified field. This island will contain /// the field's parent node, while the returned island /// will contain the connected node. Note that this /// does not gurantee that the island will be split /// into two pieces (if the nodes are still connected). /// </summary> /// <returns>The newly created island</returns> public Island Split(Field field) { var parent = field.ParentNode; var connected = field.ConnectedNode; // Find all current connections with the parent node ConnectedNodes.Clear(); _connectedFields.Clear(); FindConnected(parent, ConnectedNodes, _connectedFields); // Find all current connections with the connected node var splitNodes = new HashSet <Node>(); var splitFields = new HashSet <Field>(); FindConnected(connected, splitNodes, splitFields); // Return the island containing the connected node return(new Island(splitNodes, splitFields)); }
/// <summary> /// /// </summary> /// <param name="dst_"></param> public bool ConnectTo(NodeSlot dst_) { if (dst_.Node == Node) { throw new InvalidOperationException("Try to connect itself"); } foreach (NodeSlot s in ConnectedNodes) { if (s.Node == dst_.Node) // already connected { return(true); //throw new InvalidOperationException(""); } } switch (ConnectionType) { case SlotType.NodeIn: case SlotType.NodeOut: if ((dst_.Node is VariableNode) == true) { return(false); } break; case SlotType.VarIn: case SlotType.VarOut: case SlotType.VarInOut: if ((dst_.Node is VariableNode) == false && (dst_ is NodeSlotVar) == false) { return(false); } break; } ConnectedNodes.Add(dst_); return(true); }
/// <summary> /// Connect all anchors to the nearest nodes /// </summary> private void ConnectToNodes() { ClearNodes(); // Clear previous connections foreach (Vector anchor in Anchors) { Node node = BoardGrid.Magnetize(ImagePosition + anchor); // The nearest node Vector nodeRelativePosition = node.Position - ImagePosition; // Node position relative to the image Directions direction = new Directions(); // Direction of the component relative to the node try { if (Math.Abs(ImageSize.X - nodeRelativePosition.X) < Properties.Settings.Default.GridThickness) // The grid thickness is used as an error threshold { direction = Directions.Left; } else if (Math.Abs(ImageSize.Y - nodeRelativePosition.Y) < Properties.Settings.Default.GridThickness) { direction = Directions.Up; } else if (Math.Abs(nodeRelativePosition.Y) < Properties.Settings.Default.GridThickness) { direction = Directions.Down; } else if (Math.Abs(nodeRelativePosition.X) < Properties.Settings.Default.GridThickness) { direction = Directions.Right; } else { throw new System.ApplicationException("Can't determine anchor position relatively to the node."); } } catch (System.ApplicationException e) { ((MainWindow)Application.Current.MainWindow).LogError(e); // Write error to log and close the processus } ConnectedNodes.Add(node); node.ConnectedElements.Add(this, direction); } }
public void Dispose() { if (DiscoveredNodeGroup != null) { DiscoveredNodeGroup.Dispose(); } if (ConnectNodeGroup != null) { ConnectNodeGroup.Dispose(); } if (AddNodeNodeGroup != null) { AddNodeNodeGroup.Dispose(); } foreach (var server in _Servers) { server.Dispose(); } foreach (var node in ConnectedNodes.Where(n => n.Behaviors.Find <ConnectionManagerBehavior>().OneTry)) { node.Disconnect(); } }
/// <summary> /// Calculates the degree of this node while only considering nodes that are in the subgraph. Ignores connections to all other nodes /// </summary> /// <param name="subGraph">The subgraph to calculate the remaining degree in</param> /// <returns>The remaining degree of this node in the subgraph</returns> public int RemainingDegree(HashSet <Node> subGraph) => ConnectedNodes.Count(n => subGraph.Contains(n));
// Description: Updates the number of connections in the BuildViewNode's information // PRE: The given nodepair has an origin and a destination nodes // POST: The number of connections for these nodes has been updated private void UpdateNumberOfNodeConnections(ConnectedNodes nodePair, bool isAddingOneConnection) { int i = isAddingOneConnection ? 1 : 0; nodePair.origin.NumberOfConnections += 2 * i - 1; nodePair.destination.NumberOfConnections += 2 * i - 1; }
// Description: Adds a link between every node in order that they were selected // PRE: N/A // POST: There exists a link between every node selected (n-1 links) public void Link() { // Spawn a new link where the origin is the first index, // and the secondary node is the second node if (selectedNodes.Count >= 2) { for (int i = 1; i < selectedNodes.Count; i++) { // Keys for our hash table, connectedNodes ConnectedNodes nodePair = new ConnectedNodes(selectedNodes[i - 1], selectedNodes[i]); ConnectedNodes reversedPair = new ConnectedNodes(selectedNodes[i], selectedNodes[i - 1]); if(!connectedNodes.Contains(nodePair)) { if (connectedNodes.Contains(reversedPair)) { Destroy((GameObject) connectedNodes[reversedPair]); connectedNodes.Remove(reversedPair); UpdateNumberOfNodeConnections(reversedPair, false); } GameObject newLink = CreateLink(nodePair); connectedNodes.Add(nodePair, newLink); UpdateNumberOfNodeConnections(nodePair, true); } } this.ClearSelection(); } UpdateLinkInspector(); }
public bool IsConnectedTo(Node node) => ConnectedNodes.Any(n => n == node);
// どこからも参照されていない /* * private void AddRange(IEnumerable<Point3Di> cluster) * { * voxels.AddRange(cluster); * } */ public void AddConnectedNode(DendriteNode node) { ConnectedNodes.Add(node); }
/// <summary> /// Adds node to list of connected nodes. /// </summary> /// <param name="node">The node that will be added to the list of connected nodes.</param> public void AddConnectedNode(NodeGene node) { ConnectedNodes.Add(node); }
/// <summary> /// Returns true if the node is contained inside this island /// </summary> public bool Contains(Node node) { return(ConnectedNodes.Contains(node)); }
public Node GetNextNode() { var nextNodeName = ConnectedNodes.randomItem(); return(NodeCollection.Nodes.FirstOrDefault(x => x.Id == nextNodeName)); }
public override string ToString() { var join = string.Join(",", ConnectedNodes.Select(node => node.ToString()).ToArray()); return($"[{join}]"); }
/// <summary> /// /// </summary> public void RemoveAllConnections() { ConnectedNodes.Clear(); }
// Description: Creates the Link object to be placed between two nodes // PRE: nodePair contains two nodes // POST: There exists a link between each of the nodes in nodePair private GameObject CreateLink(ConnectedNodes nodePair) { GameObject newLink = Instantiate(LinkPrefab); newLink.tag = "Link"; BuildViewLink linkScript = newLink.GetComponent<BuildViewLink>(); linkScript.origin = nodePair.origin; linkScript.destination = nodePair.destination; return newLink; }
private void ProcessMessageCore(IncomingMessage message) { if (message.Message.Payload is VersionPayload) { var version = message.AssertPayload <VersionPayload>(); var connectedToSelf = version.Nonce == Nonce; if (message.Node != null && connectedToSelf) { NodeServerTrace.ConnectionToSelfDetected(); message.Node.DisconnectAsync(); return; } if (message.Node == null) { var remoteEndpoint = version.AddressFrom; if (!remoteEndpoint.Address.IsRoutable(AllowLocalPeers)) { //Send his own endpoint remoteEndpoint = new IPEndPoint(((IPEndPoint)message.Socket.RemoteEndPoint).Address, Network.DefaultPort); } var peer = new NetworkAddress() { Endpoint = remoteEndpoint, Time = DateTimeOffset.UtcNow }; var node = new Node(peer, Network, CreateNodeConnectionParameters(), message.Socket, version); if (connectedToSelf) { node.SendMessage(CreateNodeConnectionParameters().CreateVersion(node.Peer.Endpoint, Network)); NodeServerTrace.ConnectionToSelfDetected(); node.Disconnect(); return; } CancellationTokenSource cancel = new CancellationTokenSource(); cancel.CancelAfter(TimeSpan.FromSeconds(10.0)); try { ConnectedNodes.Add(node); node.StateChanged += node_StateChanged; node.RespondToHandShake(cancel.Token); } catch (OperationCanceledException ex) { NodeServerTrace.Error("The remote node did not respond fast enough (10 seconds) to the handshake completion, dropping connection", ex); node.DisconnectAsync(); throw; } catch (Exception) { node.DisconnectAsync(); throw; } } } var messageReceived = MessageReceived; if (messageReceived != null) { messageReceived(this, message); } }
/// <summary> /// Drop connection to all connected nodes /// </summary> public void Disconnect() { _disconnect.Cancel(); ConnectedNodes.DisconnectAll(); }
internal void StartConnecting() { if (_disconnect.IsCancellationRequested) { return; } if (ConnectedNodes.Count >= MaximumNodeConnection) { return; } if (_connecting) { return; } Task.Factory.StartNew(() => { if (Monitor.TryEnter(_cs)) { _connecting = true; TraceCorrelationScope scope = null; try { while (!_disconnect.IsCancellationRequested && ConnectedNodes.Count < MaximumNodeConnection) { scope = scope ?? _trace.Open(); NodeServerTrace.Information("Connected nodes : " + ConnectedNodes.Count + "/" + MaximumNodeConnection); var parameters = NodeConnectionParameters.Clone(); parameters.TemplateBehaviors.Add(new NodesGroupBehavior(this)); parameters.ConnectCancellation = _disconnect.Token; var addrman = AddressManagerBehavior.GetAddrman(parameters); if (addrman == null) { addrman = _defaultAddressManager; AddressManagerBehavior.SetAddrman(parameters, addrman); } Node node = null; try { var groupSelector = CustomGroupSelector ?? (AllowSameGroup ? WellKnownGroupSelectors.ByRandom : null); node = Node.Connect(_network, parameters, ConnectedNodes.Select(n => n.RemoteSocketEndpoint).ToArray(), groupSelector); var timeout = CancellationTokenSource.CreateLinkedTokenSource(_disconnect.Token); timeout.CancelAfter(5000); node.VersionHandshake(Requirements, timeout.Token); NodeServerTrace.Information("Node successfully connected to and handshaked"); } catch (OperationCanceledException ex) { if (_disconnect.Token.IsCancellationRequested) { break; } NodeServerTrace.Error("Timeout for picked node", ex); if (node != null) { node.DisconnectAsync("Handshake timeout", ex); } } catch (Exception ex) { NodeServerTrace.Error("Error while connecting to node", ex); if (node != null) { node.DisconnectAsync("Error while connecting", ex); } } } } finally { Monitor.Exit(_cs); _connecting = false; if (scope != null) { scope.Dispose(); } } } }, TaskCreationOptions.LongRunning); }
/// <summary> /// /// </summary> /// <param name="slot_"></param> public bool DisconnectFrom(NodeSlot slot_) { ConnectedNodes.Remove(slot_); return(true); }
public bool IsTouchingEnemyCapRing(Node ignore_node) { var ignore_nodes = ignore_node.ConnectedNodes; return(ConnectedNodes.Any(x => x.IsCapRing && !ignore_nodes.Contains(x) && !x.ProvinceData.IsWater)); }