protected void ContainsTestHelper <TKey, TValue>(IImmutableDictionary <TKey, TValue> map, TKey key, TValue value)
{
Assert.False(map.Contains(new KeyValuePair <TKey, TValue>(key, value)));
Assert.False(map.Contains(key, value));
Assert.True(map.Add(key, value).Contains(new KeyValuePair <TKey, TValue>(key, value)));
Assert.True(map.Add(key, value).Contains(key, value));
}
private IImmutableDictionary <IActorRef, IImmutableList <string> > CreateAllocations(int aCount, int bCount = 0, int cCount = 0)
{
IImmutableDictionary <IActorRef, IImmutableList <string> > allocations = ImmutableDictionaryKeepOrder <IActorRef, IImmutableList <string> > .Empty;
allocations = allocations.Add(regionA, shards.Take(aCount).ToImmutableList());
allocations = allocations.Add(regionB, shards.Skip(aCount).Take(bCount).ToImmutableList());
allocations = allocations.Add(regionC, shards.Skip(aCount + bCount).Take(cCount).ToImmutableList());
return(allocations);
}
/// <inheritdoc />
public Task <bool> AddAsync(IActiveLock activeLock, CancellationToken cancellationToken)
{
if (_locks.ContainsKey(activeLock.StateToken))
{
return(Task.FromResult(false));
}
_locks = _locks.Add(activeLock.StateToken, activeLock);
return(Task.FromResult(true));
}
protected void AddExistingKeySameValueTestHelper <TKey, TValue>(IImmutableDictionary <TKey, TValue> map, TKey key, TValue value1, TValue value2)
{
Assert.NotNull(map);
Assert.NotNull(key);
Assert.True(GetValueComparer(map).Equals(value1, value2));
map = map.Add(key, value1);
Assert.Same(map, map.Add(key, value2));
Assert.Same(map, map.AddRange(new[] { new KeyValuePair <TKey, TValue>(key, value2) }));
}
public static void Create()
{
IImmutableDictionary <int, string> d = ImmutableDictionary.Create <int, string>();
d = d.Add(1, "One");
d = d.Add(2, "Two");
d = d.Add(3, "Three");
System.Console.WriteLine(d[2]);
}
protected void AddExistingKeySameValueTestHelper <TKey, TValue>(IImmutableDictionary <TKey, TValue> map, TKey key, TValue value1, TValue value2)
{
Contract.Requires(map != null);
Contract.Requires(key != null);
Contract.Requires(GetValueComparer(map).Equals(value1, value2));
map = map.Add(key, value1);
Assert.Same(map, map.Add(key, value2));
Assert.Same(map, map.AddRange(new[] { new KeyValuePair <TKey, TValue>(key, value2) }));
}
public void TestAdd()
{
IImmutableDictionary <int, int> dictionary = CreateDictionary <int, int>();
Assert.Empty(dictionary);
dictionary = dictionary.Add(1, 1);
Assert.Same(dictionary, dictionary.Add(1, 1));
Assert.Throws <ArgumentException>(() => dictionary.Add(1, 2));
}
private IImmutableDictionary <IActorRef, IImmutableList <string> > CreateAllocations(int aCount, int bCount = 0, int cCount = 0)
{
var shards = Enumerable.Range(1, (aCount + bCount + cCount)).Select(i => i.ToString("000"));
IImmutableDictionary <IActorRef, IImmutableList <string> > allocations = ImmutableDictionaryKeepOrder <IActorRef, IImmutableList <string> > .Empty;
allocations = allocations.Add(_regionA, shards.Take(aCount).ToImmutableList());
allocations = allocations.Add(_regionB, shards.Skip(aCount).Take(bCount).ToImmutableList());
allocations = allocations.Add(_regionC, shards.Skip(aCount + bCount).Take(cCount).ToImmutableList());
return(allocations);
}
/// <summary>
/// Verifies that adding a key-value pair where the key already is in the map but with a different value throws.
/// </summary>
/// <typeparam name="TKey">The type of key in the map.</typeparam>
/// <typeparam name="TValue">The type of value in the map.</typeparam>
/// <param name="map">The map to manipulate.</param>
/// <param name="key">The key to add.</param>
/// <param name="value1">The first value to add.</param>
/// <param name="value2">The second value to add.</param>
/// <remarks>
/// Adding a key-value pair to a map where that key already exists, but with a different value, cannot fit the
/// semantic of "adding", either by just returning or mutating the value on the existing key. Throwing is the only reasonable response.
/// </remarks>
protected void AddExistingKeyDifferentValueTestHelper <TKey, TValue>(IImmutableDictionary <TKey, TValue> map, TKey key, TValue value1, TValue value2)
{
Assert.NotNull(map);
Assert.NotNull(key);
Assert.False(GetValueComparer(map).Equals(value1, value2));
var map1 = map.Add(key, value1);
var map2 = map.Add(key, value2);
AssertExtensions.Throws <ArgumentException>(null, () => map1.Add(key, value2));
AssertExtensions.Throws <ArgumentException>(null, () => map2.Add(key, value1));
}
/// <summary>
/// Verifies that adding a key-value pair where the key already is in the map but with a different value throws.
/// </summary>
/// <typeparam name="TKey">The type of key in the map.</typeparam>
/// <typeparam name="TValue">The type of value in the map.</typeparam>
/// <param name="map">The map to manipulate.</param>
/// <param name="key">The key to add.</param>
/// <param name="value1">The first value to add.</param>
/// <param name="value2">The second value to add.</param>
/// <remarks>
/// Adding a key-value pair to a map where that key already exists, but with a different value, cannot fit the
/// semantic of "adding", either by just returning or mutating the value on the existing key. Throwing is the only reasonable response.
/// </remarks>
protected void AddExistingKeyDifferentValueTestHelper <TKey, TValue>(IImmutableDictionary <TKey, TValue> map, TKey key, TValue value1, TValue value2)
{
Contract.Requires(map != null);
Contract.Requires(key != null);
Contract.Requires(!GetValueComparer(map).Equals(value1, value2));
var map1 = map.Add(key, value1);
var map2 = map.Add(key, value2);
Assert.Throws <ArgumentException>(() => map1.Add(key, value2));
Assert.Throws <ArgumentException>(() => map2.Add(key, value1));
}
protected override void OnReceive(object message)
{
switch (message)
{
case RequestTrackDevice trackMsg:
if (groupIdToActor.TryGetValue(trackMsg.GroupId, out var actorRef))
{
actorRef.Forward(trackMsg);
}
else
{
Log.Info($"Creating device group actor for {trackMsg.GroupId}");
var groupActor = Context.ActorOf(DeviceGroup.Props(trackMsg.GroupId), $"group-{trackMsg.GroupId}");
Context.Watch(groupActor);
groupActor.Forward(trackMsg);
groupIdToActor = groupIdToActor.Add(trackMsg.GroupId, groupActor);
actorToGroupId = actorToGroupId.Add(groupActor, trackMsg.GroupId);
}
break;
case Terminated t:
var groupId = actorToGroupId[t.ActorRef];
Log.Info($"Device group actor for {groupId} has been terminated");
actorToGroupId = actorToGroupId.Remove(t.ActorRef);
groupIdToActor = groupIdToActor.Remove(groupId);
break;
}
}
public override async Task <IImmutableDictionary <string, string> > GetGlobalPropertiesAsync(CancellationToken cancellationToken)
{
IImmutableDictionary <string, string> properties = Empty.PropertiesMap;
// Check:
// - if this is an implicitly-triggered build
// - if there is a single startup project
// - if this is the startup project in question
// - if this is a cross targeting project, i.e. project configuration has a "TargetFramework" dimension
// - if the option to prefer single-target builds is turned on
if (_implicitlyTriggeredBuildState.IsImplicitlyTriggeredBuild &&
_implicitlyTriggeredBuildState.StartupProjectFullPaths.Length == 1 &&
StringComparers.Paths.Equals(_implicitlyTriggeredBuildState.StartupProjectFullPaths[0], _configuredProject.UnconfiguredProject.FullPath) &&
_configuredProject.ProjectConfiguration.IsCrossTargeting() &&
await _projectSystemOptions.GetPreferSingleTargetBuildsForStartupProjectsAsync(cancellationToken))
{
// We only want to build this for the framework that we will launch.
string?activeDebuggingFramework = await _activeDebugFrameworkServices.GetActiveDebuggingFrameworkPropertyAsync();
if (activeDebuggingFramework is not null)
{
properties = properties.Add(ConfigurationGeneral.TargetFrameworkProperty, activeDebuggingFramework);
}
}
return(properties);
}
/// <summary>
/// Writes a <see cref="Packet"/> object to the currrent stream.
/// </summary>
/// <param name="packet">The <see cref="Packet"/> object.</param>
public void Write(Packet packet)
{
var range = new Range <long>();
range.Minimum = BaseStream.Position;
packet.Header.CopyTo(BaseStream);
packet.Body.CopyTo(BaseStream);
range.Maximum = BaseStream.Position - 1;
var overwrittenPackets = packets
.Where(x => range.IsInsideRange(new Range <long>
{
Minimum = x.Key,
Maximum = x.Key + x.Value - 1
}))
.Select(x => x.Key);
foreach (var key in overwrittenPackets)
{
packets = packets.Remove(key);
}
packets = packets.Add(range.Minimum, range.Maximum - range.Minimum + 1);
}
private IImmutableDictionary <int, IImmutableDictionary <int, int> > AddSleepyTime(
IImmutableDictionary <int, IImmutableDictionary <int, int> > slots,
int guardId,
int startMinutes,
int endMinutes)
{
IEnumerable <int> minutesInWhichAsleep = Enumerable.Range(startMinutes, endMinutes - startMinutes + 1);
if (!slots.TryGetValue(guardId, out IImmutableDictionary <int, int> guardSleepCounts))
{
var b = ImmutableDictionary.CreateRange(
minutesInWhichAsleep
.Select(i => new KeyValuePair <int, int>(i, 1)));
return(slots.Add(guardId, b.ToImmutableDictionary()));
}
guardSleepCounts = minutesInWhichAsleep
.Aggregate(
guardSleepCounts,
(s, i) => s.TryGetValue(i, out int currentSleepsThisSlot)
? s.SetItem(i, currentSleepsThisSlot + 1)
: s.Add(i, 1));
return(slots.SetItem(guardId, guardSleepCounts));
}
/// <inheritdoc />
public IImmutableDictionary <Address, object> Add(
Address key,
object value
)
{
return(new AddressStateMap(_impl.Add(key, value)));
}
public void TestRemove()
{
IImmutableDictionary <int, int> dictionary = CreateDictionary <int, int>();
for (int i = 0; i < 4; i++)
{
dictionary = dictionary.Add(i, i);
}
Assert.Same(dictionary, dictionary.Remove(4));
Assert.Equal(
new[]
{
new KeyValuePair <int, int>(0, 0),
new KeyValuePair <int, int>(1, 1),
new KeyValuePair <int, int>(2, 2),
},
dictionary.Remove(3));
Assert.Equal(
new[]
{
new KeyValuePair <int, int>(0, 0),
new KeyValuePair <int, int>(2, 2),
new KeyValuePair <int, int>(3, 3),
},
dictionary.Remove(1));
}
public static void CollectRoslynReferences(
ref IImmutableDictionary <AssemblyShortName, AssemblyDetails> usedRoslynAssemblies,
IImmutableDictionary <AssemblyShortName, string> roslynAssemblyPaths,
ref IImmutableDictionary <AssemblyShortName, AssemblyDetails> mainAssemblies,
IImmutableDictionary <AssemblyShortName, IImmutableSet <PackageInfo> > roslynPackageMap,
out IImmutableDictionary <AssemblyShortName, AssemblyDetails> othersReferencedByRoslyn
)
{
var othersReferencedByRoslynBuilder = ImmutableSortedDictionary.CreateBuilder <AssemblyShortName, AssemblyDetails>();
FluentConsole.White.Line("Analyzing Roslyn references…");
var seen = new HashSet <AssemblyShortName>();
var queue = new Queue <AssemblyDetails>(usedRoslynAssemblies.Values);
while (queue.Count > 0)
{
var assembly = queue.Dequeue();
FluentConsole.Gray.Line($" {assembly.Definition.Name.Name}");
seen.Add(assembly.Definition.Name.Name);
foreach (var reference in assembly.Definition.MainModule.AssemblyReferences)
{
if (!seen.Add(reference.Name))
{
continue;
}
FluentConsole.Gray.Line($" {reference.FullName}");
mainAssemblies = mainAssemblies.Remove(reference.Name);
if (usedRoslynAssemblies.ContainsKey(reference.Name))
{
FluentConsole.Gray.Line(" [roslyn assembly, already used]");
continue;
}
var roslynAssemblyPath = roslynAssemblyPaths.GetValueOrDefault(reference.Name);
if (roslynAssemblyPath != null)
{
FluentConsole.Gray.Line(" [roslyn assembly, queued]");
var roslynAssembly = AssemblyDetails.ReadFrom(roslynAssemblyPath, readSymbols: true);
usedRoslynAssemblies = usedRoslynAssemblies.Add(roslynAssembly.Definition.Name.Name, roslynAssembly);
queue.Enqueue(roslynAssembly);
continue;
}
if (InGlobalAssemblyCache(reference))
{
FluentConsole.Gray.Line(" [gac]");
continue;
}
var referencedAssembly = GetAssemblyDetailsFromNuGetCache(reference.Name, roslynPackageMap);
if (referencedAssembly == null)
{
FluentConsole.Gray.Line(" [system?]");
continue;
}
othersReferencedByRoslynBuilder.Add(reference.Name, referencedAssembly);
queue.Enqueue(referencedAssembly);
}
}
othersReferencedByRoslyn = othersReferencedByRoslynBuilder.ToImmutable();
}
public async Task AddWorkout(Workout workout)
{
CheckIsNotNull(nameof(workout), workout);
_workouts = _workouts.Add(workout.WorkoutId, workout);
await Task.CompletedTask;
}
public async Task AddExercise(Exercise exercise)
{
CheckIsNotNull(nameof(exercise), exercise);
_exercises = _exercises.Add(exercise.ExerciseId, exercise);
await Task.CompletedTask;
}
public async Task AddDeck(Deck deck)
{
CheckIsNotNull(nameof(deck), deck);
_decks = _decks.Add(deck.DeckId, deck);
await Task.CompletedTask;
}
protected static void ContainsKeyTestHelper <TKey, TValue>(
IImmutableDictionary <TKey, TValue> map,
TKey key,
TValue value
)
{
Assert.False(map.ContainsKey(key));
Assert.True(map.Add(key, value).ContainsKey(key));
}
private IWriteHandler CheckBaseClasses(Type type)
{
Type baseType = type.GetTypeInfo().BaseType;
while (baseType != null && baseType != typeof(object))
{
IWriteHandler handler;
if (handlers.TryGetValue(baseType, out handler))
{
handlers = handlers.Add(type, handler);
return(handler);
}
baseType = baseType.GetTypeInfo().BaseType;
}
return(null);
}
public static IImmutableDictionary <string, IProjectRuleSnapshot> Add(this IImmutableDictionary <string, IProjectRuleSnapshot> snapshots, string ruleName, string propertyName, string propertyValue)
{
if (!snapshots.TryGetValue(ruleName, out IProjectRuleSnapshot snapshot))
{
snapshot = IProjectRuleSnapshotFactory.Create(ruleName, propertyName, propertyValue);
return(snapshots.Add(ruleName, snapshot));
}
return(snapshots.SetItem(ruleName, snapshot.Add(propertyName, propertyValue)));
}
public void TestClear()
{
IImmutableDictionary <int, int> dictionary = CreateDictionary <int, int>();
Assert.Empty(dictionary);
Assert.Same(dictionary, dictionary.Clear());
dictionary = dictionary.Add(1, 1);
Assert.Empty(dictionary.Clear());
}
protected void ValuesTestHelper<TKey, TValue>(IImmutableDictionary<TKey, TValue> map, TKey key)
{
Assert.Equal(0, map.Values.Count());
Assert.Equal(0, map.ToReadOnlyDictionary().Values.Count());
var nonEmpty = map.Add(key, default(TValue));
Assert.Equal(1, nonEmpty.Values.Count());
Assert.Equal(1, nonEmpty.ToReadOnlyDictionary().Values.Count());
KeysOrValuesTestHelper(((IDictionary<TKey, TValue>)nonEmpty).Values, default(TValue));
}
private bool IsNamespaceMatch(Type type)
{
if (!namespaceScratchPad.ContainsKey(type))
{
var ns = type.Namespace ?? "";
var match = config.ModelNamespaces.Any(ns.StartsWith);
namespaceScratchPad = namespaceScratchPad.Add(type, match);
}
return(namespaceScratchPad[type]);
}
/// <summary>
/// Gets a new or existing section descriptor
/// </summary>
/// <typeparam name="T">The type of the configuration section</typeparam>
/// <returns>The section descriptor for <see cref="T:self"/></returns>
internal static IConfigurationSectionDescriptor GetSectionDescriptor <T>(string sectionKey)
where T : class, IConfigurationSection <T>
{
if (sectionDescriptors.ContainsKey(typeof(T)))
{
return(sectionDescriptors[typeof(T)]);
}
sectionDescriptors = sectionDescriptors.Add(typeof(T), new ConfigurationSectionDescriptor <T>(sectionKey));
return(sectionDescriptors[typeof(T)]);
}
/// <summary>
/// Gets a new or existing collection descriptor
/// </summary>
/// <typeparam name="T">The type of the configuration collection</typeparam>
/// <returns>The collection descriptor for <see cref="T:self"/></returns>
internal static IConfigurationCollectionDescriptor GetCollectionDescriptor <T>()
where T : class, IConfigurationCollection <T>
{
if (collectionDescriptors.ContainsKey(typeof(T)))
{
return(collectionDescriptors[typeof(T)]);
}
collectionDescriptors = collectionDescriptors.Add(typeof(T), new ConfigurationCollectionDescriptor <T>());
return(collectionDescriptors[typeof(T)]);
}
/// <summary>
/// Gets the set of global properties that should apply to the project(s) in this scope.
/// </summary>
/// <value>A map whose keys are case insensitive. Never null, but may be empty.</value>
public override Task <IImmutableDictionary <string, string> > GetGlobalPropertiesAsync(CancellationToken cancellationToken)
{
IImmutableDictionary <string, string> properties = Empty.PropertiesMap;
if (_overrideGeneratePackageOnBuild.HasValue)
{
properties = properties.Add(ConfigurationGeneralBrowseObject.GeneratePackageOnBuildProperty, _overrideGeneratePackageOnBuild.Value ? "true" : "false");
}
return(Task.FromResult(properties));
}
public override IImmutableDictionary <TKey, TValue> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
// Validate parameters.
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
// Is this null? If so, return null.
if (reader.TokenType == JsonTokenType.Null)
{
return(null !);
}
// If it is not an object, throw.
if (reader.TokenType != JsonTokenType.StartObject)
{
throw new JsonException($"Expected a token type of {nameof(JsonTokenType.StartObject)}, encountered {reader.TokenType}.");
}
// The return value.
IImmutableDictionary <TKey, TValue> values = ImmutableDictionary <TKey, TValue> .Empty;
// Cycle.
while (reader.Read() && reader.TokenType == JsonTokenType.PropertyName)
{
// We should be on the name now. Get the string.
string stringKey = reader.GetString();
// Convert the key.
TKey key = _keyDeserializer(stringKey, options);
// Move the reader now.
if (!reader.Read())
{
throw new JsonException($"Expected call to {nameof(Utf8JsonReader.Read)} to return true, returned false.");
}
// Deserialize the value.
TValue value = _valueDeserializer(ref reader, options);
// Add.
values = values.Add(key, value);
}
// If the token is not an end object, throw.
if (reader.TokenType != JsonTokenType.EndObject)
{
throw new JsonException($"Expected a token of {JsonTokenType.EndObject}, actual {reader.TokenType}.");
}
// Return the values.
return(values);
}
/// <summary>
/// Writes a <see cref="Packet"/> object to the currrent stream.
/// </summary>
/// <param name="packet">The <see cref="Packet"/> object.</param>
public void Write(Packet packet)
{
var range = new Range<long>();
range.Minimum = BaseStream.Position;
packet.Header.CopyTo(BaseStream);
packet.Body.CopyTo(BaseStream);
range.Maximum = BaseStream.Position - 1;
var overwrittenPackets = packets
.Where(x => range.IsInsideRange(new Range<long>
{
Minimum = x.Key,
Maximum = x.Key + x.Value - 1
}))
.Select(x => x.Key);
foreach (var key in overwrittenPackets)
{
packets = packets.Remove(key);
}
packets = packets.Add(range.Minimum, range.Maximum - range.Minimum + 1);
}
