public void SerializeDictionary()
{
ImmutableDictionary <int, string> l = ImmutableDictionary.CreateRange(new Dictionary <int, string>
{
{ 1, "One" },
{ 2, "II" },
{ 3, "3" }
});
string json = JsonConvertX.SerializeObject(l, Formatting.Indented);
JObject a = JObject.Parse(json);
Assert.AreEqual(3, a.Count);
Assert.AreEqual("One", (string)a["1"]);
Assert.AreEqual("II", (string)a["2"]);
Assert.AreEqual("3", (string)a["3"]);
}
public void ReadImmutableDictionaryOfInt32()
{
ImmutableDictionary <int, int> expected = ImmutableDictionary.CreateRange(new Dictionary <int, int>
{
{ 1, 1 },
{ 2, 2 },
{ 3, 3 }
});
const string json = @"{""1"":1,""2"":2,""3"":3}";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
ImmutableDictionary <int, int> actual = JsonSerializer.Deserialize <ImmutableDictionary <int, int> >(json, options);
Assert.Equal(expected, actual);
}
public void SerializeDictionary()
{
ImmutableDictionary <int, string> data = ImmutableDictionary.CreateRange(new Dictionary <int, string>
{
{ 1, "One" },
{ 2, "II" },
{ 3, "3" }
});
string json = JsonSerializer.Serialize(data, s_indentedOption);
ImmutableDictionary <int, string> a = JsonSerializer.Deserialize <ImmutableDictionary <int, string> >(json);
Assert.Equal(3, a.Count);
Assert.Equal("One", (string)a[1]);
Assert.Equal("II", (string)a[2]);
Assert.Equal("3", (string)a[3]);
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is PropertyDeclarationSyntax propertyDeclaration &&
context.ContainingSymbol is IPropertySymbol property &&
property.ContainingType.IsAssignableTo(KnownSymbols.MarkupExtension, context.Compilation) &&
!Attribute.TryFind(propertyDeclaration, KnownSymbols.ConstructorArgumentAttribute, context.SemanticModel, context.CancellationToken, out _) &&
ConstructorArgument.TryGetParameterName(property, context.SemanticModel, context.CancellationToken, out var parameterName))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0083UseConstructorArgumentAttribute,
propertyDeclaration.Identifier.GetLocation(),
ImmutableDictionary.CreateRange(new[] { new KeyValuePair <string, string>(nameof(ConstructorArgument), parameterName) }),
parameterName));
}
}
public void ORSet_must_verify_SubtractDots()
{
var dot = VersionVector.Create(ImmutableDictionary.CreateRange(new Dictionary <UniqueAddress, long>
{
{ _nodeA, 3L }, { _nodeB, 2L }, { _nodeD, 14L }, { _nodeG, 22L }
}));
var vvector = VersionVector.Create(ImmutableDictionary.CreateRange(new Dictionary <UniqueAddress, long>
{
{ _nodeA, 4L }, { _nodeB, 1L }, { _nodeC, 1L }, { _nodeD, 14L }, { _nodeE, 5L }, { _nodeF, 2L }
}));
var expected = VersionVector.Create(ImmutableDictionary.CreateRange(new Dictionary <UniqueAddress, long>
{
{ _nodeB, 2L }, { _nodeG, 22L }
}));
ORSet.SubtractDots(dot, vvector).Should().Be(expected);
}
public void WriteImmutableDictionaryOfInt32()
{
ImmutableDictionary <int, int> value = ImmutableDictionary.CreateRange(new Dictionary <int, int>
{
{ 1, 1 },
{ 2, 2 },
{ 3, 3 }
});
const string expected = @"{""1"":1,""2"":2,""3"":3}";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
string actual = JsonSerializer.Serialize(value, value.GetType(), options);
Assert.Equal(expected, actual);
}
private static void Analyze(SyntaxNodeAnalysisContext context, MemberDeclarationSyntax declaration, SyntaxTokenList modifiers)
{
Accessibility accessibility = GetAccessibility(context, declaration, modifiers);
if (accessibility == Accessibility.NotApplicable)
return;
Location location = GetLocation(declaration);
if (location == null)
return;
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.AddAccessibilityModifiers,
location,
ImmutableDictionary.CreateRange(new KeyValuePair<string, string>[] { new KeyValuePair<string, string>(nameof(Accessibility), accessibility.ToString()) }));
}
protected virtual void LoadWords()
{
using (var ctx = GetNewContext())
{
IDsToWords = ImmutableDictionary.CreateRange(
ctx.Words.ToList().Select(kvp => CreateKVP(kvp.ID, kvp.WordString))
);
var wordsToNouns = new Dictionary <string, List <Noun> >();
foreach (Noun noun in ctx.Nouns)
{
string lowerWord = IDsToWords[noun.WordID].ToLowerInvariant();
List <Noun> existingNouns;
if (!wordsToNouns.TryGetValue(lowerWord, out existingNouns))
{
existingNouns = new List <Noun>();
wordsToNouns[lowerWord] = existingNouns;
}
existingNouns.Add(noun);
}
LowerWordToNouns = ImmutableDictionary.CreateRange(
wordsToNouns.Select(kvp => CreateKVP(kvp.Key, ImmutableList.CreateRange(kvp.Value)))
);
var wordsToAdjectives = new Dictionary <string, List <Adjective> >();
foreach (Adjective adj in ctx.Adjectives)
{
string lowerWord = IDsToWords[adj.WordID].ToLowerInvariant();
List <Adjective> existingAdjectives;
if (!wordsToAdjectives.TryGetValue(lowerWord, out existingAdjectives))
{
existingAdjectives = new List <Adjective>();
wordsToAdjectives[lowerWord] = existingAdjectives;
}
existingAdjectives.Add(adj);
}
LowerWordToAdjectives = ImmutableDictionary.CreateRange(
wordsToAdjectives.Select(kvp => CreateKVP(kvp.Key, ImmutableList.CreateRange(kvp.Value)))
);
}
}
public static void Main()
{
string?searchType = null;
while (true)
{
Console.Write("Depth-first or Breadth-first search? (d/b): ");
searchType = Console.ReadLine();
if ((searchType == "d") || (searchType == "b"))
{
break;
}
Console.WriteLine("Invalid Selection");
Console.WriteLine();
}
try
{
var findStarted = DateTime.UtcNow;
var initialState = new PuzzleState(
AirTimeMinutesRemaining: 21,
AstronautLocations: ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <Astronaut, StationSection>(Astronaut.Neil, StationSection.SectionA),
new KeyValuePair <Astronaut, StationSection>(Astronaut.Michael, StationSection.SectionA),
new KeyValuePair <Astronaut, StationSection>(Astronaut.Valentina, StationSection.SectionA),
new KeyValuePair <Astronaut, StationSection>(Astronaut.Yuri, StationSection.SectionA),
new KeyValuePair <Astronaut, StationSection>(Astronaut.Edwin, StationSection.SectionA)
}),
SuitsLocation: StationSection.SectionA);
var(solution, solutionsChecked) = (searchType == "d")
? PuzzleSolution.FindDepth(initialState)
: PuzzleSolution.FindBreadth(initialState);
var findDuration = DateTime.UtcNow - findStarted;
Console.WriteLine("Solution found");
Console.WriteLine("Steps:");
foreach (var mutation in solution.Mutations)
{
Console.WriteLine($"\t{string.Join(" and ", mutation.AstronautsMoved)} spend{((mutation.AstronautsMoved.Length == 1) ? "s" : "")} {mutation.TravelTimeMinutes} minute{((mutation.TravelTimeMinutes == 1) ? "" : "s")} moving to {mutation.TargetStationSection}");
}
var finalState = solution.States[^ 1];
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (context.IsExcludedFromAnalysis())
{
return;
}
if (context.Node is ObjectCreationExpressionSyntax objectCreation &&
context.SemanticModel.TryGetSymbol(objectCreation, context.CancellationToken, out var ctor))
{
if (objectCreation.ArgumentList is ArgumentListSyntax argumentList &&
argumentList.Arguments.Count > 0 &&
context.ContainingSymbol is IMethodSymbol method &&
ctor.ContainingType.IsEither(KnownSymbol.ArgumentException, KnownSymbol.ArgumentNullException, KnownSymbol.ArgumentOutOfRangeException) &&
ctor.TryFindParameter("paramName", out var nameParameter))
{
if (objectCreation.TryFindArgument(nameParameter, out var nameArgument) &&
objectCreation.Parent is ThrowExpressionSyntax throwExpression &&
throwExpression.Parent is BinaryExpressionSyntax binary &&
binary.IsKind(SyntaxKind.CoalesceExpression) &&
nameArgument.TryGetStringValue(context.SemanticModel, context.CancellationToken, out var name) &&
binary.Left is IdentifierNameSyntax identifierName &&
identifierName.Identifier.ValueText != name)
{
var properties = ImmutableDictionary.CreateRange(
new[] { new KeyValuePair <string, string>("Name", identifierName.Identifier.ValueText) });
context.ReportDiagnostic(
Diagnostic.Create(
GU0013CheckNameInThrow.Descriptor,
nameArgument.GetLocation(),
properties));
}
if (TryGetWithParameterName(argumentList, method.Parameters, out var argument) &&
argument.NameColon == null &&
objectCreation.ArgumentList.Arguments.IndexOf(argument) != ctor.Parameters.IndexOf(nameParameter))
{
context.ReportDiagnostic(
Diagnostic.Create(
GU0005ExceptionArgumentsPositions.Descriptor,
argument.GetLocation()));
}
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation, MemberAccessExpressionSyntax memberAccess)
{
if (SyntaxAnalyzer.IsEnumerableExtensionMethod(invocation, "Count", 1, context.SemanticModel, context.CancellationToken))
{
string propertyName = SyntaxHelper.GetCountOrLengthPropertyName(memberAccess.Expression, context.SemanticModel, allowImmutableArray: true, cancellationToken: context.CancellationToken);
if (propertyName != null)
{
TextSpan span = TextSpan.FromBounds(memberAccess.Name.Span.Start, invocation.Span.End);
if (invocation
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
Diagnostic diagnostic = Diagnostic.Create(
DiagnosticDescriptors.ReplaceCountMethodWithCountOrLengthProperty,
Location.Create(context.Node.SyntaxTree, span),
ImmutableDictionary.CreateRange(new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("PropertyName", propertyName) }),
propertyName);
context.ReportDiagnostic(diagnostic);
}
}
else if (invocation.Parent?.IsKind(
SyntaxKind.EqualsExpression,
SyntaxKind.GreaterThanExpression,
SyntaxKind.LessThanExpression) == true)
{
var binaryExpression = (BinaryExpressionSyntax)invocation.Parent;
if (IsFixableBinaryExpression(binaryExpression))
{
TextSpan span = TextSpan.FromBounds(invocation.Span.End, binaryExpression.Span.End);
if (binaryExpression
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.ReplaceCountMethodWithAnyMethod,
binaryExpression.GetLocation());
}
}
}
}
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is AttributeSyntax attribute &&
context.SemanticModel.TryGetNamedType(attribute, KnownSymbols.XmlnsDefinitionAttribute, context.CancellationToken, out _))
{
using var walker = Walker.Create(context.SemanticModel.Compilation, context.SemanticModel, context.CancellationToken);
if (walker.NotMapped.Count != 0)
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0052XmlnsDefinitionsDoesNotMapAllNamespaces,
attribute.GetLocation(),
ImmutableDictionary.CreateRange(walker.NotMapped.Select(x => new KeyValuePair <string, string?>(x, x))),
string.Join(Environment.NewLine, walker.NotMapped)));
}
}
}
public void ORMultiDictionary_must_be_able_to_add_entries()
{
var m = ORMultiValueDictionary <string, string> .Empty.AddItem(_node1, "a", "A").AddItem(_node1, "b", "B");
Assert.Equal(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, IImmutableSet <string> >("a", ImmutableHashSet.Create("A")),
new KeyValuePair <string, IImmutableSet <string> >("b", ImmutableHashSet.Create("B"))
}), m.Entries);
var m2 = m.AddItem(_node1, "a", "C");
Assert.Equal(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, IImmutableSet <string> >("a", ImmutableHashSet.Create("A", "C")),
new KeyValuePair <string, IImmutableSet <string> >("b", ImmutableHashSet.Create("B"))
}), m2.Entries);
}
private object CoordinatorStateFromBinary(byte[] binary)
{
using (var stream = Decompress(binary))
{
var state = CoordinatorState.ParseFrom(stream);
var shards = ImmutableDictionary.CreateRange(state.ShardsList.Select(entry => new KeyValuePair <string, IActorRef>(entry.ShardId, ResolveActorRef(entry.RegionRef))));
var regionsZero = ImmutableDictionary.CreateRange(state.RegionsList.Select(region => new KeyValuePair <IActorRef, IImmutableList <string> >(ResolveActorRef(region), ImmutableList <string> .Empty)));
var regions = shards.Aggregate(regionsZero, (acc, entry) => acc.SetItem(entry.Value, acc[entry.Value].Add(entry.Key)));
var proxies = state.RegionProxiesList.Select(ResolveActorRef).ToImmutableHashSet();
var unallocatedShards = state.UnallocatedShardsList.ToImmutableHashSet();
return(new PersistentShardCoordinator.State(
shards: shards,
regions: regions,
regionProxies: proxies,
unallocatedShards: unallocatedShards));
}
}
private ImmutableDictionary <string, PropertyInfo> PropertyInfoDictionaryFromSchema()
{
var entries = new List <KeyValuePair <string, PropertyInfo> >();
if (_schema.Properties != null)
{
foreach (KeyValuePair <string, JsonSchema> schemaProperty in _schema.Properties)
{
string propertyName = schemaProperty.Key;
JsonSchema propertySchema = schemaProperty.Value;
bool isRequired = _schema.Required?.Contains(propertyName) == true;
AddPropertyInfoFromPropertySchema(entries, propertyName, propertySchema, isRequired);
}
}
return(ImmutableDictionary.CreateRange(entries));
}
public Unit Execute(ModelEntity e)
{
var excludedTypes = new[] { TaggedValueTypes.Const("").TypeName };
var tvs = ImmutableDictionary.CreateRange(
from tv in e.TaggedValues
join proto in ADTechnology.Technologies.AD.TaggedValues on tv.Key equals proto.Name
where !proto.Type.TypeName.In(excludedTypes)
select tv);
Form.GetSelected(tvs).Do(selectedTVs =>
{
var selectedTags = selectedTVs.Select(p => p.Key).ToImmutableHashSet();
Clipboard.Exchange(new TaggedValuesClipboard(e, selectedTags), GetType());
});
return(Unit.Instance);
}
public void A_LWWDictionary_should_be_able_to_have_its_entries_correctly_merged_with_another_LWWMap_with_other_entries()
{
var m1 = LWWDictionary.Create(
Tuple.Create(_node1, "a", 1),
Tuple.Create(_node1, "b", 2));
var m2 = LWWDictionary.Create(_node2, "c", 3);
var expected = ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, int>("a", 1),
new KeyValuePair <string, int>("b", 2),
new KeyValuePair <string, int>("c", 3),
});
// merge both ways
Assert.Equal(expected, m1.Merge(m2).Entries);
Assert.Equal(expected, m2.Merge(m1).Entries);
}
internal virtual async Task <ImmutableDictionary <Project, ImmutableArray <Diagnostic> > > GetProjectDiagnosticsToFixAsync(
FixAllContext fixAllContext)
{
using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Diagnostics, fixAllContext.CancellationToken))
{
var project = fixAllContext.Project;
if (project != null)
{
switch (fixAllContext.Scope)
{
case FixAllScope.Project:
var diagnostics = await fixAllContext.GetProjectDiagnosticsAsync(project).ConfigureAwait(false);
var kvp = SpecializedCollections.SingletonEnumerable(KeyValuePair.Create(project, diagnostics));
return(ImmutableDictionary.CreateRange(kvp));
case FixAllScope.Solution:
var projectsAndDiagnostics = ImmutableDictionary.CreateBuilder <Project, ImmutableArray <Diagnostic> >();
var tasks = project.Solution.Projects.Select(async p => new
{
Project = p,
Diagnostics = await fixAllContext.GetProjectDiagnosticsAsync(p).ConfigureAwait(false)
}).ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
foreach (var task in tasks)
{
var projectAndDiagnostics = await task.ConfigureAwait(false);
if (projectAndDiagnostics.Diagnostics.Any())
{
projectsAndDiagnostics[projectAndDiagnostics.Project] = projectAndDiagnostics.Diagnostics;
}
}
return(projectsAndDiagnostics.ToImmutable());
}
}
return(ImmutableDictionary <Project, ImmutableArray <Diagnostic> > .Empty);
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation, MemberAccessExpressionSyntax memberAccess)
{
if (invocation.Parent?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == false &&
SyntaxAnalyzer.IsEnumerableExtensionMethod(invocation, "Any", 1, context.SemanticModel, context.CancellationToken))
{
string propertyName = SyntaxHelper.GetCountOrLengthPropertyName(memberAccess.Expression, context.SemanticModel, allowImmutableArray: false, cancellationToken: context.CancellationToken);
if (propertyName != null)
{
string messageArg = null;
TextSpan span = TextSpan.FromBounds(memberAccess.Name.Span.Start, invocation.Span.End);
if (invocation.DescendantTrivia(span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
if (invocation.Parent?.IsKind(SyntaxKind.LogicalNotExpression) == true)
{
var logicalNot = (PrefixUnaryExpressionSyntax)invocation.Parent;
if (logicalNot.OperatorToken.TrailingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
logicalNot.Operand.GetLeadingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
messageArg = $"{propertyName} == 0";
}
}
else
{
messageArg = $"{propertyName} > 0";
}
}
if (messageArg != null)
{
Diagnostic diagnostic = Diagnostic.Create(
DiagnosticDescriptors.ReplaceAnyMethodWithCountOrLengthProperty,
Location.Create(context.Node.SyntaxTree, span),
ImmutableDictionary.CreateRange(new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("PropertyName", propertyName) }),
messageArg);
context.ReportDiagnostic(diagnostic);
}
}
}
}
private static void Handle(ExpressionSyntax mutation, ExpressionSyntax backing, SyntaxNodeAnalysisContext context)
{
if (context.ContainingSymbol.ContainingType is { } containingType&&
containingType.IsAssignableTo(KnownSymbol.INotifyPropertyChanged, context.Compilation) &&
mutation.TryFirstAncestorOrSelf <TypeDeclarationSyntax>(out var typeDeclaration))
{
using var pathWalker = MemberPath.PathWalker.Borrow(backing);
if (!pathWalker.TryFirst(out var firstTokenInPath))
{
return;
}
var firstIdentifierNameSymbol = context.SemanticModel.GetSymbolInfo(firstTokenInPath.Parent, context.CancellationToken).Symbol;
if (firstIdentifierNameSymbol?.ContainingType != containingType)
{
return;
}
foreach (var member in typeDeclaration.Members)
{
if (member is PropertyDeclarationSyntax propertyDeclaration &&
propertyDeclaration.Modifiers.Any(SyntaxKind.PublicKeyword, SyntaxKind.InternalKeyword) &&
ExpressionBodyOrGetter(propertyDeclaration) is { } getter&&
!getter.Contains(backing) &&
PropertyPath.Uses(getter, pathWalker, context) &&
!Property.IsLazy(propertyDeclaration, context.SemanticModel, context.CancellationToken) &&
context.SemanticModel.GetDeclaredSymbolSafe(propertyDeclaration, context.CancellationToken) is { } property&&
PropertyChanged.InvokesPropertyChangedFor(mutation, property, context.SemanticModel, context.CancellationToken) == AnalysisResult.No)
{
if (context.Node.TryFirstAncestor(out PropertyDeclarationSyntax? inProperty) &&
ReferenceEquals(inProperty, propertyDeclaration) &&
Property.TrySingleReturned(inProperty, out var returned) &&
PropertyPath.Uses(backing, returned, context))
{
// We let INPC002 handle this
continue;
}
var properties = ImmutableDictionary.CreateRange(new[] { new KeyValuePair <string, string>(PropertyNameKey, property.Name), });
context.ReportDiagnostic(Diagnostic.Create(Descriptors.INPC003NotifyForDependentProperty, context.Node.GetLocation(), properties, property.Name));
}
}
}
}
private async Task <ImmutableDictionary <Document, ImmutableArray <TextSpan> > > GetFixAllSpansAsync(
Document document, TextSpan span, bool fixAllInContainingMember, CancellationToken cancellationToken)
{
var decl = await GetContainingMemberOrTypeDeclarationAsync(document, fixAllInContainingMember, span, cancellationToken).ConfigureAwait(false);
if (decl == null)
{
return(await GetFixAllSpansIfWithinGlobalStatementAsync(document, span, cancellationToken).ConfigureAwait(false));
}
if (fixAllInContainingMember)
{
return(ImmutableDictionary.CreateRange(SpecializedCollections.SingletonEnumerable(
KeyValuePairUtil.Create(document, ImmutableArray.Create(decl.FullSpan)))));
}
else
{
var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var symbol = semanticModel.GetDeclaredSymbol(decl, cancellationToken);
if (symbol?.DeclaringSyntaxReferences.Length > 1)
{
var syntaxFacts = document.GetRequiredLanguageService <ISyntaxFactsService>();
var builder = PooledDictionary <Document, ArrayBuilder <TextSpan> > .GetInstance();
foreach (var syntaxRef in symbol.DeclaringSyntaxReferences)
{
var documentForLocation = document.Project.GetDocument(syntaxRef.SyntaxTree);
Contract.ThrowIfNull(documentForLocation);
var root = await syntaxRef.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var partialDeclSpan = syntaxFacts.GetContainingTypeDeclaration(root, syntaxRef.Span.Start) !.FullSpan;
builder.MultiAdd(documentForLocation, partialDeclSpan);
}
return(builder.ToImmutableMultiDictionaryAndFree());
}
else
{
return(ImmutableDictionary.CreateRange(SpecializedCollections.SingletonEnumerable(
KeyValuePairUtil.Create(document, ImmutableArray.Create(decl.FullSpan)))));
}
}
}
internal ORDictionary <TKey, TValue> AddOrUpdate(UniqueAddress node, TKey key, TValue initial, bool valueDeltas,
Func <TValue, TValue> modify)
{
bool hasOldValue;
if (!ValueMap.TryGetValue(key, out var oldValue))
{
oldValue = initial;
hasOldValue = false;
}
else
{
hasOldValue = true;
}
// Optimization: for some types - like GSet, GCounter, PNCounter and ORSet - that are delta based
// we can emit (and later merge) their deltas instead of full updates.
// However to avoid necessity of tombstones, the derived map type needs to support this
// with clearing the value (e.g. removing all elements if value is a set)
// before removing the key - like e.g. ORMultiMap does
var newKeys = KeySet.ResetDelta().Add(node, key);
if (valueDeltas && oldValue is IDeltaReplicatedData deltaOldValue)
{
var newValue = modify((TValue)deltaOldValue.ResetDelta());
var newValueDelta = ((IDeltaReplicatedData)newValue).Delta;
if (newValueDelta != null && hasOldValue)
{
var op = new UpdateDeltaOperation(newKeys.Delta, ImmutableDictionary.CreateRange(new[] { new KeyValuePair <TKey, IReplicatedData>(key, newValueDelta) }));
return(new ORDictionary <TKey, TValue>(newKeys, ValueMap.SetItem(key, newValue), NewDelta(op)));
}
else
{
var op = new PutDeltaOperation(newKeys.Delta, key, newValue);
return(new ORDictionary <TKey, TValue>(newKeys, ValueMap.SetItem(key, newValue), NewDelta(op)));
}
}
else
{
var newValue = modify(oldValue);
var delta = new PutDeltaOperation(newKeys.Delta, key, newValue);
return(new ORDictionary <TKey, TValue>(newKeys, ValueMap.SetItem(key, newValue), NewDelta(delta)));
}
}
public App()
{
var states = ImmutableDictionary.CreateRange(
new Dictionary <string, object>()
{
{ DisplayFormat, Constants.TimeSpanFormatNoMillsecond },
{ NowSpan, TimeSpan.Zero },
{ Mode, StopwatchMode.Init },
{ ButtonLabel, Constants.StartLabel },
{ StartTime, new DateTime() },
{ Now, new DateTime() },
{ LapTimeList, new ObservableCollection <LapTime>() },
{ MaxLapTime, TimeSpan.Zero },
{ MinLapTime, TimeSpan.Zero },
});
var initialState = new ApplicationState(states, _scheduler);
Store = new Store <ApplicationState>(Reducers.ReduceApplication, initialState);
}
private void CreateTypeBuilderConfig()
{
var typeMappings = new Dictionary <string, TsTypeReference>();
void AddTypeMappingsFromAssembly(Assembly asm)
{
foreach (var attribute in TypeUtils.GetAssemblyCustomAttributesData(asm).Where(a =>
a.AttributeType.Name == Constants.DefineTypeScriptTypeForExternalTypeAttributeName && a.ConstructorArguments.Count == 2 && a.ConstructorArguments[1].Value is string))
{
string key;
if (attribute.ConstructorArguments[0].Value is Type type)
{
key = TypeUtils.GetFullNameWithGenericArguments(type);
}
else if (attribute.ConstructorArguments[0].Value is string s)
{
key = s;
}
else
{
continue;
}
typeMappings[key] = TsTypeReference.Simple((string)attribute.ConstructorArguments[1].Value);
}
}
foreach (var assembly in _generatorContext.Assemblies)
{
AddTypeMappingsFromAssembly(assembly);
}
// override mappings from config
foreach (var mapping in _config.TypeMappings)
{
var reference = TsTypeReference.Simple(mapping.Value);
typeMappings[mapping.Key] = reference;
}
var mappings = ImmutableDictionary.CreateRange(typeMappings);
_typeBuilderConfig = new TypeBuilderConfig(mappings, _config.CustomTypeScriptIgnoreAttributeFullName, _config.WrapConstEnumsInTemplateStrings);
}
public Image Build()
{
return(new Image(
imageFormat,
created,
architecture,
os,
imageLayersBuilder.Build(),
historyBuilder.ToImmutable(),
ImmutableDictionary.CreateRange(environmentBuilder),
entrypoint,
programArguments,
healthCheck,
ImmutableHashSet.CreateRange(exposedPortsBuilder),
ImmutableHashSet.CreateRange(volumesBuilder),
ImmutableDictionary.CreateRange(labelsBuilder),
workingDirectory,
user));
}
public async Task <IReadOnlyDictionary <string, DeferredProjectInformation> > GetDeferredProjectInfoForConfigurationAsync(
string solutionConfiguration,
CancellationToken cancellationToken)
{
var commandLineInfos = await _solutionWorkspaceService.Value.GetManagedCommandLineInfoAsync(
solutionConfiguration, cancellationToken).ConfigureAwait(false);
// NOTE: Anycode gives us the project references as if they were command line arguments with
// "/ProjectReference:" prepended. Strip that off here.
var result = ImmutableDictionary.CreateRange(
commandLineInfos.Select(kvp => KeyValuePair.Create(
kvp.Key,
new DeferredProjectInformation(
kvp.Value.TargetPath,
kvp.Value.CommandLineArgs,
kvp.Value.ProjectReferences.Select(p => p.Substring("/ProjectReference:".Length)).ToImmutableArray()))));
return(result);
}
public void DeltaPropagationSelector_must_collect_1_when_one_node()
{
var selector = new TestSelector(selfUniqueAddress, nodes.Take(1).ToImmutableArray());
selector.Update("A", DeltaA);
selector.Update("B", DeltaB);
selector.CleanupDeltaEntries();
selector.HasDeltaEntries("A").Should().BeTrue();
selector.HasDeltaEntries("B").Should().BeTrue();
var expected = new DeltaPropagation(selfUniqueAddress, false, ImmutableDictionary <string, Delta> .Empty
.Add("A", new Delta(new DataEnvelope(DeltaA), 1L, 1L))
.Add("B", new Delta(new DataEnvelope(DeltaB), 1L, 1L)));
selector.CollectPropagations().Should().Equal(ImmutableDictionary.CreateRange(new[] { new KeyValuePair <Address, DeltaPropagation>(nodes[0], expected), }));
selector.CollectPropagations().Should().BeEmpty();
selector.CleanupDeltaEntries();
selector.HasDeltaEntries("A").Should().BeFalse();
selector.HasDeltaEntries("B").Should().BeFalse();
}
public static void Analyze(SyntaxNodeAnalysisContext context, MemberDeclarationSyntax declaration)
{
SyntaxTokenList modifiers = declaration.GetModifiers();
Accessibility accessibility = GetAccessModifier(context, declaration, modifiers);
if (accessibility != Accessibility.NotApplicable)
{
Location location = GetLocation(declaration);
if (location != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddDefaultAccessModifier,
location,
ImmutableDictionary.CreateRange(new KeyValuePair <string, string>[] { new KeyValuePair <string, string>(nameof(Accessibility), accessibility.ToString()) }));
}
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="records">TBD</param>
public Cache(ImmutableList <Record> records)
{
if (records.IsEmpty)
{
_observerRowsMap = ImmutableDictionary.Create <UniqueAddress, ImmutableDictionary <UniqueAddress, Record> >();
_allTerminated = ImmutableHashSet.Create <UniqueAddress>();
_allUnreachable = ImmutableHashSet.Create <UniqueAddress>();
}
else
{
var mapBuilder = new Dictionary <UniqueAddress, ImmutableDictionary <UniqueAddress, Record> >();
var terminatedBuilder = ImmutableHashSet.CreateBuilder <UniqueAddress>();
var unreachableBuilder = ImmutableHashSet.CreateBuilder <UniqueAddress>();
foreach (var r in records)
{
ImmutableDictionary <UniqueAddress, Record> m = mapBuilder.TryGetValue(r.Observer, out m)
? m.SetItem(r.Subject, r)
//TODO: Other collections take items for Create. Create unnecessary array here
: ImmutableDictionary.CreateRange(new[] { new KeyValuePair <UniqueAddress, Record>(r.Subject, r) });
mapBuilder.AddOrSet(r.Observer, m);
if (r.Status == ReachabilityStatus.Unreachable)
{
unreachableBuilder.Add(r.Subject);
}
else if (r.Status == ReachabilityStatus.Terminated)
{
terminatedBuilder.Add(r.Subject);
}
}
_observerRowsMap = ImmutableDictionary.CreateRange(mapBuilder);
_allTerminated = terminatedBuilder.ToImmutable();
_allUnreachable = unreachableBuilder.ToImmutable().Except(AllTerminated);
}
_allUnreachableOrTerminated = _allTerminated.IsEmpty
? AllUnreachable
: AllUnreachable.Union(AllTerminated);
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (context.IsExcludedFromAnalysis())
{
return;
}
if (context.Node is LiteralExpressionSyntax literal &&
literal.Parent is ArgumentSyntax &&
SyntaxFacts.IsValidIdentifier(literal.Token.ValueText))
{
foreach (var symbol in context.SemanticModel.LookupSymbols(literal.SpanStart, name: literal.Token.ValueText))
{
switch (symbol)
{
case IParameterSymbol _:
context.ReportDiagnostic(Diagnostic.Create(Descriptors.GU0006UseNameof, literal.GetLocation()));
break;
case IFieldSymbol _:
case IEventSymbol _:
case IPropertySymbol _:
case IMethodSymbol _:
if (symbol.IsStatic)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptors.GU0006UseNameof, literal.GetLocation()));
}
else
{
var properties = ImmutableDictionary.CreateRange(new[] { new KeyValuePair <string, string>("member", symbol.Name) });
context.ReportDiagnostic(Diagnostic.Create(Descriptors.GU0006UseNameof, literal.GetLocation(), properties));
}
break;
case ILocalSymbol local when IsVisible(literal, local, context.CancellationToken):
context.ReportDiagnostic(Diagnostic.Create(Descriptors.GU0006UseNameof, literal.GetLocation()));
break;
}
}
}
}