/// <inhertidoc /> public void AddLink(IMLink link, Parameters parameters) { IMNode neighbour = link.OtherEnd(this); //Add the link referenced by both its own UUID and the ID of the neighbour it connects to lock (_links) { if (!_links.ContainsKey(neighbour.ID)) { _links.Add(neighbour.ID, link); } if (!_links.ContainsKey(link.ID)) { _links.Add(link.ID, link); } } lock (_neighbours) if (!_neighbours.ContainsKey(link.ID)) { _neighbours.Add(link.ID, neighbour); } link.OnWeightChanged += _weightDelegate; if (OnLinkAdded != null) { OnLinkAdded(ID, link, parameters); Logger.Debug(Name + " triggered OnLinkAdded for '" + link.Name + "'."); } }
protected bool GetPaused(string name, UUID id) { if (!_paused.ContainsKey(id)) { _paused.Add(id, false); } return(_paused[id]); }
public void RegisterPrim(IPrim prim) { if (_prims.ContainsKey(prim.ID)) { return; } lock (_prims) _prims.Add(prim.ID, prim); }
/// <summary> /// Map a string to an ID so it can be looked up when serializing and deserializing. /// </summary> /// <param name="id"></param> /// <param name="name"></param> private T MapID <T>(T instance) where T : class, ILogicEntity { if (_readerMap.ContainsKey(instance.Name)) { _readerMap[instance.Name] = instance.ID; } else { _readerMap.Add(instance.Name, instance.ID); } _reader.MapInstance <T>(instance); if (_recordingEnabled) { IXmlLogWriter <T> writer = new OpenSimLogWriter <T>(_writerMap, instance, HostPrim.Pos, true); _writers.Add(instance.ID, writer); _writerMap.Add(instance.ID, instance.Name); if (_currentlyRecording) { writer.StartRecording(_modelWriter.Log); } return(writer.Instance); } return(instance); }
public T Make <T>(T instance, bool recursive) where T : class { if (!_recordingEnabled) { _reader.MapInstance <T>(instance, !recursive); return(instance); } IXmlLogWriter <T> writer = new OpenSimLogWriter <T>(_writerMap, instance, _hostPrim.Pos, true, recursive);; if (_baseWriter == null) { _baseWriter = writer; } else { _writers.Add(UUID.Random(), writer); } if (_currentlyRecording) { writer.StartRecording(); } _reader.MapInstance <T>(writer.Instance, !recursive); return(writer.Instance); }
public virtual void AddStateButton(UUID id, IButton button) { if (!_stateButtons.ContainsKey(id)) { _stateButtons.Add(id, new List <IButton>()); } _stateButtons[id].Add(button); }
protected override IMNodeExternal MakeNode(string name, Parameters parameters, Vector3 position, Color colour) { Logger.Debug("Creating node '" + name + "'."); MNode node = new MNode(_view.AddNode(name, parameters, position, colour), _view.Send, _currentAlgorithm, _algorithms, TableFactory); _knownNodes.Add(node.ID, node); node.OnForwardingTableChange += (id, routes) => _view.UpdateForwardingTable(id, routes); Logger.Info("Created node '" + name + "'."); return(node); }
/// <summary> /// Used to specify that the route to a target node is along the specified AddLink /// </summary> /// <param name = "target">The node to map a route to</param> /// <param name = "link">The AddLink along which to pass packets intended for target node</param> public void SetWIPRoute(UUID target, IMLink link) { lock (_wipRoute) { if (_wipRoute.ContainsKey(target)) { _wipRoute[target] = link; } else { _wipRoute.Add(target, link); } } }
public virtual INode AddNode(string name, Parameters parameters, Vector3 position = default(Vector3), Color colour = default(Color)) { if (name == null) { throw new Exception("Unable to add entity. Name cannot be null"); } lock (this) { TNode node = MakeNode(name, parameters, position, colour); _nodes.Add(node.ID, node); _neighbours.Add(node.ID, TableFactory.MakeKeyTable <TNode>()); _connections.Add(node.ID, TableFactory.MakeKeyTable <TLink>()); Logger.Debug("Stored node '" + name + "'."); return(node); } }
private void OnSelected(string name, UUID id) { Control.State.SetState(SandboxControl.LinkSelected, name, id); Control.State.SetSelectedPrim(ID, name, id); if (!_bufferedChanges.ContainsKey(id)) { _bufferedChanges.Add(id, Weight); } else { _bufferedChanges[id] = Weight; } ShowLinkDialog(name, id); }
public OriginalControl(IKeyTableFactory tableFactory, IAsynchQueueFactory queueFactory, IPrimFactory primFactory, IModel model, UUID hostID, IConfigSource config) : base(tableFactory, queueFactory) { _hostPrim = primFactory[hostID]; _readerMap = new Dictionary <string, UUID>(); _writerMap = tableFactory.MakeKeyTable <string>(); _paused = tableFactory.MakeKeyTable <bool>(); IConfig controlConfig = config.Configs["Control"]; IConfig commonConfig = config.Configs["Common"]; if (controlConfig == null) { controlConfig = config.Configs[0]; } if (commonConfig == null) { commonConfig = config.Configs[0]; } _wait = commonConfig.GetInt("Wait", 50); _userFolder = controlConfig.Get("UserFolder", "."); _recordingEnabled = controlConfig.GetBoolean("RecordingEnabled", false); _timing = controlConfig.GetBoolean("TimedPlayback", true); _schemaFile = controlConfig.GetString("TopologySchema", null); _reader = new OpenSimLogReader(_readerMap, model, HostPrim.Pos); _reader.MapInstance <IModule>(this); _writers = tableFactory.MakeKeyTable <IXmlLogWriter>(); _factory = primFactory; if (_recordingEnabled) { _modelWriter = new OpenSimLogWriter <IModel>(_writerMap, model, HostPrim.Pos, true, false); _model = _modelWriter.Instance; IXmlLogWriter <IModule> baseWriter = new OpenSimLogWriter <IModule>(_writerMap, this, HostPrim.Pos, true); _recordingBase = baseWriter.Instance; _writers.Add(hostID, baseWriter); } else { _model = model; } Namespace = controlConfig.Get("Namespace", Namespace); Logger.Info("Control started."); }
public virtual void AddToggle(UUID id, Toggle toggle) { if (!_toggles.ContainsKey(id)) { _toggles.Add(id, new Dictionary <string, Toggle>()); } if (!_toggles[id].ContainsKey(toggle.Name)) { _toggles[id].Add(toggle.Name, toggle); } else { _toggles[id][toggle.Name] = toggle; } }
/// <summary> /// Trigger the node to display its forwarding table. /// </summary> /// <param name="node">The ID of the node to display the forwarding table for.</param> /// <param name="routes">The strings which represent each route the forwarding table knows of.</param> public void DisplayForwardingTable(UUID node, Route[] routes, params UUID[] boards) { if (!IsNode(node)) { return; } _factory.Host.Say("Displaying forwarding table. " + boards.Length + " buttons selected for " + GetNode(node).Name + "."); foreach (UUID board in boards) { if (board == UUID.Zero) { continue; } if (_displayingBoards.ContainsKey(board)) { foreach (UUID oldNode in _displayingBoards[board]) { if (!oldNode.Equals(node) && IsNode(oldNode)) { GetNode(oldNode).RemoveBoard(board); } } _displayingBoards[board] = _displayingBoards[board].Concat(new UUID[] { node }); } else { _displayingBoards.Add(board, new UUID[] { node }); } } new Thread(() => { try { GetNode(node). DisplayForwardingTable(routes, boards. Where(board => !board.Equals(UUID.Zero) && _factory.PrimExists(board)). Select <UUID, IPrim>(board => _factory[board])); } catch (Exception e) { Logger.Warn("Problem displaying board. " + e.Message); } }).Start(); }
public override void ProcessPacket(IMPacket p) { if (!Links.ContainsKey(p.S)) { _unknownPacket = p; return; } DVPacket packet = p as DVPacket; lock (neighbourVectors) //Add the new distance vector to the collection of known distance vectors if (!neighbourVectors.ContainsKey(p.S)) { neighbourVectors.Add(p.S, packet.DistanceVector); } else { neighbourVectors[p.S] = packet.DistanceVector; } findShortestPaths(packet.TTL, "Distance Vector receiving '" + p.Name + "'", p.Visualise); }
internal void SetDistanceFromRoot(UUID root, float value, DijkstraNode prevNode, IMLink link) { //if (prevNode != null/* && !Links.ContainsKey(prevNode.ID)*/) // return; lock (_distances) { if (_distances.ContainsKey(root)) { _distances[root] = value; _prev[root] = prevNode; } else { _distances.Add(root, value); _prev.Add(root, prevNode); } } if (prevNode != null) { SetWIPRoute(root, link); } }
protected void SetRoute(string alg, UUID target, IMLink link, float dist) { if (_table.ContainsKey(target)) { IMLink oldLink = _table[target]; float oldDist = _distances[target]; _table[target] = link; _distances[target] = dist; if (OnRouteChange != null && IsCurrentAlgorithm && (!link.Equals(oldLink) || dist != oldDist)) { OnRouteChange(alg, KnownNodes[target], oldLink, link, oldDist, dist); } } else { _table.Add(target, link); _distances.Add(target, dist); if (OnRouteChange != null && IsCurrentAlgorithm) { OnRouteChange(alg, KnownNodes[target], null, link, -1f, dist); } } }
public virtual ILink AddLink(UUID from, UUID to, Parameters parameters, float weight = default(float), bool bidirectional = true) { lock (this) { CheckLinksPair(from, to, "add"); if (AreLinked(from, to)) { throw new Exception("Unable to add link. '" + _nodes[from].Name + "' and '" + _nodes[to] + "' are alread linked."); } TLink link = MakeLink(from, to, parameters, weight, bidirectional); _links.Add(link.ID, link); _neighbours[from].Add(link.ID, _nodes[to]); _connections[from].Add(to, link); if (bidirectional) { _neighbours[to].Add(link.ID, _nodes[from]); _connections[to].Add(from, link); } Logger.Debug("Stored '" + link.Name + "'."); return(link); } }