private Task StartWorker(Func <int, Task> work) { int workerId = idleWorkers.Min(); idleWorkers = idleWorkers.Remove(workerId); Task doingWork = Task.Run ( async() => { try { await work(workerId); } finally { CompleteWork(workerId); } } ); busyWorkers = busyWorkers.Add(workerId); return(Task.FromResult(doingWork)); }
public void start() { this.server.Start(socket => { socket.OnOpen = () => { FleckLog.Info($"{socket.ConnectionInfo.Id} (from {socket.ConnectionInfo.Host}) has connected. Negotiated protocol: {socket.ConnectionInfo.NegotiatedSubProtocol}"); allClients = allClients.Add(socket); publishStateUpdate(socket); }; socket.OnClose = () => { FleckLog.Info($"{socket.ConnectionInfo.Id} has disconnected"); allClients = allClients.Remove(socket); headPoseClients = headPoseClients.Remove(socket); gazePointDataClients = gazePointDataClients.Remove(socket); eyePositionClients = eyePositionClients.Remove(socket); }; socket.OnError = (err) => { FleckLog.Warn($"{socket.ConnectionInfo.Id} had error: {err}"); }; socket.OnMessage = message => { handleEyeNavMessage(socket, message); FleckLog.Info($"{socket.ConnectionInfo.Id} sent message: {message}"); }; }); }
/// <summary> /// When this event is triggered on a project item, a copy of the file is saved to the /// <see cref="documentRepository" />. /// </summary> public override int OnBeforeSave(uint docCookie) { LocalHistoryPackage.Log($"Entering {nameof(OnBeforeSave)}() on {nameof(LocalHistoryDocumentListener)}"); uint pgrfRDTFlags; uint pdwReadLocks; uint pdwEditLocks; string pbstrMkDocument; IVsHierarchy ppHier; uint pitemid; IntPtr ppunkDocData; documentTable.GetDocumentInfo( docCookie, out pgrfRDTFlags, out pdwReadLocks, out pdwEditLocks, out pbstrMkDocument, out ppHier, out pitemid, out ppunkDocData); var filePath = Utils.NormalizePath(pbstrMkDocument); if (LocalHistoryPackage.Instance.OptionsPage.CreateRevisionOnlyIfDirty) { if (!_dirtyDocCookie.Contains(docCookie)) { LocalHistoryPackage.Log($"File \"{filePath}\" is not dirty. Will not create version."); return(VSConstants.S_OK); } _dirtyDocCookie.Remove(docCookie); } LocalHistoryPackage.Log($"Creating version for file \"{filePath}\" (is dirty)."); var revNode = documentRepository.CreateRevision(filePath); var content = LocalHistoryPackage.Instance.ToolWindow?.Content as LocalHistoryControl; //only insert if this revision is different from all the others //otherwise we would be inserting duplicates in the list //remember that DocumentNode has its own GetHashCode ObservableCollection <DocumentNode> items = content?.DocumentItems; if (revNode != null && items?.Contains(revNode) == false) { LocalHistoryPackage.Log($"Adding file \"{filePath}\" to list."); items.Insert(0, revNode); LocalHistoryPackage.Instance.UpdateToolWindow("", true); return(VSConstants.S_OK); } LocalHistoryPackage.Log($"File \"{filePath}\" is already in list. Doing nothing."); return(VSConstants.S_OK); }
public void RemovePackage(InteractivePackage package) { if (package == null) { return; } installedPackages = installedPackages.Remove(package); UpdateInstalledPackages(); }
private void ReceiveMemberRemoved(Member m) { if (m.Address == _selfAddress) { Context.Stop(Self); } else if (MatchingRole(m)) { _nodes = _nodes.Remove(m.Address); _log.Debug("Adding removed node [{0}] from MemberRemoved", m.UniqueAddress); _removedNodes = _removedNodes.SetItem(m.UniqueAddress, _allReachableClockTime); _unreachable = _unreachable.Remove(m.Address); } }
public TestClientListener(IActorRef targetClient) { _targetClient = targetClient; _contactPoints = ImmutableHashSet <ActorPath> .Empty; Receive <GetLatestContactPoints>(_ => { Sender.Tell(new LatestContactPoints(_contactPoints)); }); Receive <ContactPoints>(cps => { // Now do something with the up-to-date "cps" _contactPoints = cps.ContactPointsList; }); Receive <ContactPointAdded>(cp => { // Now do something with an up-to-date "contactPoints + cp" _contactPoints = _contactPoints.Add(cp.ContactPoint); }); Receive <ContactPointRemoved>(cp => { // Now do something with an up-to-date "contactPoints - cp" _contactPoints = _contactPoints.Remove(cp.ContactPoint); }); }
protected void RemoveOrphanVehicles() { foreach (var orphanVehicle in VehiclesSet.Where(x => x.CanBeRemoved).ToArray()) { VehiclesSet = VehiclesSet.Remove(orphanVehicle); } }
public IEnumerable <RemoteObserver> GetRelevantSubscribers(PublishOptions options) { ImmutableHashSet <RemoteObserver> result = mRemoteObservers; if (options.Eligible != null) { var eligibleObservers = GetRemoteObservers(options.Eligible) .ToArray(); result = ImmutableHashSet.Create(eligibleObservers); } bool excludeMe = options.ExcludeMe ?? true; PublishOptionsExtended casted = options as PublishOptionsExtended; if (excludeMe && casted != null) { result = result.Remove(new RemoteObserver(casted.PublisherId)); } if (options.Exclude != null) { var excludedObservers = options.Exclude.Select (sessionId => new RemoteObserver(sessionId)); result = result.Except(excludedObservers); } return(result); }
public AnalyzerData analyzedVirtualMethod(VirtualMethod virtualMethod) { return(new AnalyzerData( usedTypes, analyzedMethods, virtualMethodsToAnalyze.Remove(virtualMethod), analyzedVirtualMethods.Add(virtualMethod) )); }
public override void BeforeRemove( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder) { if (!dependency.TopLevel || !dependency.Resolved) { return; } if (dependency.Flags.Contains(DependencyTreeFlags.PackageNodeFlags)) { // find sdk with the same name and clean dependencyIDs var sdkModelId = dependency.Name; var sdkId = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, sdkModelId); if (worldBuilder.TryGetValue(sdkId, out IDependency sdk)) { // clean up sdk when corresponding package is removing sdk = sdk.SetProperties( dependencyIDs: ImmutableList <string> .Empty, resolved: false, flags: DependencyTreeFlags.SdkSubTreeNodeFlags .Union(DependencyTreeFlags.UnresolvedFlags) .Except(DependencyTreeFlags.ResolvedFlags)); worldBuilder.Remove(sdk.Id); worldBuilder.Add(sdk.Id, sdk); topLevelBuilder.Remove(sdk); topLevelBuilder.Add(sdk); } } }
/// <summary> /// Called when a new order is triggered. Updates the strategy. /// </summary> /// <param name="order">The order that was triggered.</param> private void OnOrderTriggered(OrderInfo order) { switch (order.OrderAction) { case EOrderAction.Buy: case EOrderAction.Sell: longPosition.UpdatePosition(order); break; case EOrderAction.SellShort: case EOrderAction.BuyToCover: shortPosition.UpdatePosition(order); break; default: throw new ArgumentException("Invalid OrderAction"); } strategyInfo.MarketPosition = Size; // No need to track orders after they're filled validatedOrders = validatedOrders.Remove(order); untriggeredOrders = untriggeredOrders.Remove(order); previousSubmittedOrders = previousSubmittedOrders.Remove(order); }
/// <summary> /// Have this FunctionRef unwatch the given Actor. This method must not be /// called concurrently from different threads, it should only be called by /// its parent Actor. /// </summary> public void Unwatch(IActorRef actorRef) { _watching = _watching.Remove(actorRef); var internalRef = (IInternalActorRef)actorRef; internalRef.SendSystemMessage(new Unwatch(internalRef, this)); }
public TestReceptionistListener(IActorRef targetReceptionist) { _targetReceptionist = targetReceptionist; _clusterClients = ImmutableHashSet <IActorRef> .Empty; Receive <GetLatestClusterClients>(_ => { Sender.Tell(new LatestClusterClients(_clusterClients)); }); Receive <ClusterClients>(cs => { // Now do something with the up-to-date "c" _clusterClients = cs.ClusterClientsList; }); Receive <ClusterClientUp>(c => { // Now do something with an up-to-date "clusterClients + c" _clusterClients = _clusterClients.Add(c.ClusterClient); }); Receive <ClusterClientUnreachable>(c => { // Now do something with an up-to-date "clusterClients - c" _clusterClients = _clusterClients.Remove(c.ClusterClient); }); }
public IDependency BeforeRemove( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder, out bool filterAnyChanges) { filterAnyChanges = _filterAnyChanges; if (_beforeRemove.TryGetValue(dependency.Id, out Tuple <IDependency, FilterAction> info)) { if (info.Item2 == FilterAction.Cancel) { return(null); } else if (info.Item2 == FilterAction.ShouldBeAdded) { worldBuilder.Remove(info.Item1.Id); worldBuilder.Add(info.Item1.Id, info.Item1); } else { worldBuilder.Remove(dependency.Id); topLevelBuilder.Remove(dependency); } } return(dependency); }
public TuringMachine Advanced() { if (IsHalted) { return(this); } if (IsStuckInALoop) { return(this); } var curState = new InstructionSelector(State, Tape.Contains(Position)); var instruction = Instructions[curState]; var newState = instruction.NewMachineState; if (newState < 0) { return(new TuringMachine(Instructions, Position, Tape, newState, ElapsedSteps + 1, PreviousState)); } var newTape = instruction.NewTapeValue ? Tape.Add(Position) : Tape.Remove(Position); var newPosition = Position + (instruction.ThenMoveRightward ? 1 : -1); var newPreviousState = ElapsedSteps.IsPowerOfTwo ? Tuple.Create(State, Tape) : PreviousState; return(new TuringMachine(Instructions, newPosition, newTape, newState, ElapsedSteps + 1, newPreviousState)); }
public void Deactivate(QueueItem item) { processor.EnsureOnProcessorThread(); activeCount--; activeItems = activeItems.Remove(item); }
private void CompleteWork(int workerId) { lock (syncRoot) { busyWorkers = busyWorkers.Remove(workerId); idleWorkers = idleWorkers.Add(workerId); if (waitingWorkItems.Count > 0) { WaitingWorkItem wwi = waitingWorkItems.Dequeue(); if (wwi.work is Func <int, Task> ) { wwi.k.PostResult(StartWorker((Func <int, Task>)wwi.work)); } else { wwi.k.PostResult(StartWorker((Func <int, CancellationToken, Task>)wwi.work, wwi.ctoken)); } if (wwi.ctr.HasValue) { wwi.ctr.Value.Dispose(); } } } }
public IDisposable Subscribe(IObserver <int> observer) { _observers = _observers.Add(observer); return(Disposable.Create(() => { _observers = _observers.Remove(observer); })); }
private static void Write(Node root, ImmutableHashSet <Edge> edges, TextWriter writer, IDictionary <Node, int> ranks, ISet <Edge> visited = null, int depth = 0) { if (visited == null) { visited = new HashSet <Edge>(); } if (ranks.TryGetValue(root, out var currentRank)) { ranks[root] = Math.Min(depth, currentRank); } else { ranks[root] = depth; } foreach (var edge in edges.Where(x => x.Start.Equals(root)).OrderBy(x => x.End.Type)) { if (!visited.Add(edge)) { continue; } writer.WriteLine(edge.End is PackageReferenceNode ? $"\"{edge.Start.Id}\" -> \"{edge.End.Id}\" [label=\"{edge.Label}\" color=\"blue\"];" : $"\"{edge.Start.Id}\" -> \"{edge.End.Id}\""); Write(edge.End, edges.Remove(edge), writer, ranks, visited, depth + 1); } }
public Entry <T> Purge(int sessionId) { var entry = this; var pendings = _pendingSessions; var next = _next; var disposeDomain = false; if (_pendingSessions != null) { pendings = _pendingSessions.Remove(sessionId); disposeDomain = pendings.Count == 0; } if (disposeDomain) { Domain.Dispose(); if (_next == null) { return(null); } return(_next.Purge(sessionId)); } if (_next != null) { next = _next.Purge(sessionId); } return(new Entry <T>(this, next, pendings)); }
public Wallet Put(Coin coin) { if (coin.Total == decimal.Zero) { return(this); } Coin oldValue; var newCoinValue = _coins.TryGetValue(coin, out oldValue) ? oldValue.Add(coin.Count) : coin; var updatedWallet = _coins .Remove(oldValue) .Add(newCoinValue); return(new Wallet(updatedWallet)); }
protected override bool Receive(object message) => message.Match() .With <WriteAck>(x => { Remaining = Remaining.Remove(SenderAddress); if (IsDone) { Reply(isTimeout: false); } }) .With <WriteNack>(x => { _gotNackFrom = _gotNackFrom.Add(SenderAddress); if (IsDone) { Reply(isTimeout: false); } }) .With <DeltaNack>(_ => { // ok, will be retried with full state }) .With <UpdateSuccess>(x => { _gotLocalStoreReply = true; if (IsDone) { Reply(isTimeout: false); } }) .With <StoreFailure>(x => { _gotLocalStoreReply = true; _gotNackFrom = _gotNackFrom.Remove(_selfUniqueAddress.Address); if (IsDone) { Reply(isTimeout: false); } }) .With <SendToSecondary>(x => { // Deltas must be applied in order and we can't keep track of ordering of // simultaneous updates so there is a chance that the delta could not be applied. // Try again with the full state to the primary nodes that have not acked. if (_delta != null) { foreach (var address in PrimaryNodes.Intersect(Remaining)) { Replica(address).Tell(_write); } } foreach (var n in SecondaryNodes) { Replica(n).Tell(_write); } }) .With <ReceiveTimeout>(x => Reply(isTimeout: true)) .WasHandled;
internal async Task <bool> TryRemoveUser(IUser user) { var dmchannel = await user.GetOrCreateDMChannelAsync().ConfigureAwait(false); await _service.Logger(new LogMessage(LogSeverity.Debug, LogSource, $"Removing DM channel #{dmchannel.Id}")).ConfigureAwait(false); return(GameTracker.Instance.TryRemoveGameChannel(dmchannel) && _builder.Remove(user)); }
public bool Remove(T item) { if (!factory.itemToIndex.TryGetValue(item, out var index)) { return(false); } hashCode = 0; return(set.Remove(index)); }
/// <summary> /// Remove a word from this set /// </summary> /// <param name="word">The word to remove from the set.</param> /// <returns>A new vocabulary set without this word.</returns> public VocabularySet Remove(VocabularyWord word) { if (word == null) { throw new ArgumentNullException(nameof(word)); } if (!Words.Contains(word)) { throw new ArgumentException( $"The word with spelling {word.Spelling} does not exist in this set.", nameof(word)); } var words = _words.Remove(word); return(new VocabularySet(this, words: words)); }
public void ImmutableSetAdapter_Ctor_Succeeds() { const int NumberOfMethods = 17; int[] methodsCalled = new int[NumberOfMethods]; ImmutableHashSet <int> realSet = ImmutableHashSet <int> .Empty; System.Collections.Immutable.IImmutableSet <int> backingSet = new MockSystemImmutableSet <int>( addDelegate: x => { methodsCalled[0]++; return(realSet.Add(x)); }, clearDelegate: () => { methodsCalled[1]++; return(realSet.Clear()); }, containsDelegate: x => { methodsCalled[2]++; return(realSet.Contains(x)); }, countDelegate: () => { methodsCalled[3]++; return(realSet.Count); }, equalsDelegate: null, exceptDelegate: x => { methodsCalled[4]++; return(realSet.Except(x)); }, getEnumeratorDelegate: () => { methodsCalled[5]++; return(realSet.GetEnumerator()); }, getHashCodeDelegate: null, intersectDelegate: x => { methodsCalled[6]++; return(realSet.Intersect(x)); }, isProperSubsetOfDelegate: x => { methodsCalled[7]++; return(realSet.IsProperSubsetOf(x)); }, isProperSupersetOfDelegate: x => { methodsCalled[8]++; return(realSet.IsProperSupersetOf(x)); }, isSubsetOfDelegate: x => { methodsCalled[9]++; return(realSet.IsSubsetOf(x)); }, isSupersetOfDelegate: x => { methodsCalled[10]++; return(realSet.IsSupersetOf(x)); }, overlapsDelegate: x => { methodsCalled[11]++; return(realSet.Overlaps(x)); }, removeDelegate: x => { methodsCalled[12]++; return(realSet.Remove(x)); }, setEqualsDelegate: x => { methodsCalled[13]++; return(realSet.SetEquals(x)); }, symmetricExceptDelegate: x => { methodsCalled[14]++; return(realSet.SymmetricExcept(x)); }, toStringDelegate: null, tryGetValueDelegate: (int x, out int y) => { methodsCalled[15]++; return(realSet.TryGetValue(x, out y)); }, unionDelegate: x => { methodsCalled[16]++; return(realSet.Union(x)); }); #pragma warning disable IDE0028 // Simplify collection initialization. Intentionally calling .Add separately for clarity ImmutableSetAdapter <int> set = new ImmutableSetAdapter <int>(backingSet); #pragma warning restore IDE0028 // Simplify collection initialization. set.Add(12); set.Clear(); set.Contains(12); _ = set.Count; set.Except(Array.Empty <int>()); set.GetEnumerator(); set.Intersect(Array.Empty <int>()); set.IsProperSubsetOf(Array.Empty <int>()); set.IsProperSupersetOf(Array.Empty <int>()); set.IsSubsetOf(Array.Empty <int>()); set.IsSupersetOf(Array.Empty <int>()); set.Overlaps(Array.Empty <int>()); set.Remove(12); set.SetEquals(Array.Empty <int>()); set.SymmetricExcept(Array.Empty <int>()); set.TryGetValue(12, out _); set.Union(Array.Empty <int>()); for (int counter = 0; counter < NumberOfMethods; counter++) { Assert.AreEqual(1, methodsCalled[counter]); } }
private void Remove(UniqueAddress node) { if (_scheduledUnreachable.TryGetValue(node, out var source)) { source.Cancel(); } _scheduledUnreachable = _scheduledUnreachable.Remove(node); _pendingUnreachable = _pendingUnreachable.Remove(node); }
public Task Unsubscribe(IDependencyObject observer) { _tickables = _tickables.Remove(observer); if (_tickables.IsEmpty) { _fixedUpdate.Stop(); } return(Task.CompletedTask); }
protected override bool Receive(object message) => message.Match() .With <WriteAck>(x => { Remaining = Remaining.Remove(SenderAddress); if (IsDone) { Reply(isTimeout: false); } }) .With <WriteNack>(x => { _gotNackFrom = _gotNackFrom.Remove(SenderAddress); if (IsDone) { Reply(isTimeout: false); } }) .With <UpdateSuccess>(x => { _gotLocalStoreReply = true; if (IsDone) { Reply(isTimeout: false); } }) .With <StoreFailure>(x => { _gotLocalStoreReply = true; _gotNackFrom = _gotNackFrom.Remove(Cluster.Cluster.Get(Context.System).SelfAddress); if (IsDone) { Reply(isTimeout: false); } }) .With <SendToSecondary>(x => { foreach (var n in SecondaryNodes) { Replica(n).Tell(_write); } }) .With <ReceiveTimeout>(x => Reply(isTimeout: true)) .WasHandled;
public override IDependency BeforeAdd( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder, Dictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviders, HashSet <string> projectItemSpecs, out bool filterAnyChanges) { filterAnyChanges = false; IDependency resultDependency = dependency; if (!dependency.TopLevel) { return(resultDependency); } if (dependency.Flags.Contains(DependencyTreeFlags.SdkSubTreeNodeFlags)) { // find package with the same name var packageModelId = dependency.Name; var packageId = Dependency.GetID(targetFramework, PackageRuleHandler.ProviderTypeString, packageModelId); if (worldBuilder.TryGetValue(packageId, out IDependency package) && package.Resolved) { filterAnyChanges = true; resultDependency = dependency.ToResolved( schemaName: ResolvedSdkReference.SchemaName, dependencyIDs: package.DependencyIDs); } } else if (dependency.Flags.Contains(DependencyTreeFlags.PackageNodeFlags) && dependency.Resolved) { // find sdk with the same name var sdkModelId = dependency.Name; var sdkId = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, sdkModelId); if (worldBuilder.TryGetValue(sdkId, out IDependency sdk)) { filterAnyChanges = true; sdk = sdk.ToResolved( schemaName: ResolvedSdkReference.SchemaName, dependencyIDs: dependency.DependencyIDs); worldBuilder.Remove(sdk.Id); worldBuilder.Add(sdk.Id, sdk); topLevelBuilder.Remove(sdk); topLevelBuilder.Add(sdk); } } return(resultDependency); }