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);
}
