private static bool AllValuesSame(IReadOnlyDictionary <string, List <string> > x, IReadOnlyDictionary <string, List <string> > y)
{
return(!x.Any(kvp =>
!y.ContainsKey(kvp.Key) ||
!AllValuesSame(kvp.Value, y[kvp.Key])
) && y.All(kvp => x.ContainsKey(kvp.Key)));
}
public MimeTypeProvider(IReadOnlyDictionary <string, string> mimeTypesByExtension)
{
if (!mimeTypesByExtension.All(x => x.Key.StartsWith(".")))
{
throw new Exception("The keys in the dictionary needs to all start with a '.'");
}
this.mimeTypesByExtension = mimeTypesByExtension.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase);
}
public async Task GroupByBudgetAccountGroupAsync_WhenCalled_ReturnsReadOnlyDictionaryWhichContainsBudgetAccountCollectionMatchingEachBudgetAccountGroupFromBudgetAccountsInBudgetAccountCollection()
{
IBudgetAccountCollection sut = CreateSut();
sut.Add(CreateBudgetAccountCollection());
IReadOnlyDictionary <IBudgetAccountGroup, IBudgetAccountCollection> result = await sut.GroupByBudgetAccountGroupAsync();
Assert.That(result.All(item => item.Value.All(budgetAccount => budgetAccount.BudgetAccountGroup.Number == item.Key.Number)), Is.True);
}
private bool DictEquals <TKey, TValue>(
IReadOnlyDictionary <TKey, TValue> dictA,
IReadOnlyDictionary <TKey, TValue> dictB)
{
return(dictA.Count == dictB.Count &&
dictA.All(kvpA =>
{
TValue valueB;
return dictB.TryGetValue(kvpA.Key, out valueB) && Equals(kvpA.Value, valueB);
}));
}
public static bool DictionaryEqual <TKey, TVal>(this IReadOnlyDictionary <TKey, TVal> dictionary1, IReadOnlyDictionary <TKey, TVal> dictionary2)
{
if (dictionary1 == null)
{
throw new ArgumentNullException("dictionary1");
}
if (dictionary2 == null)
{
throw new ArgumentNullException("dictionary2");
}
return(dictionary1.Count == dictionary2.Count &&
dictionary1.All(dictionary2.Contains));
}
public ComposedPart(ComposablePartDefinition definition, IReadOnlyDictionary <ImportDefinitionBinding, IReadOnlyList <ExportDefinitionBinding> > satisfyingExports, IImmutableSet <string> requiredSharingBoundaries)
{
Requires.NotNull(definition, nameof(definition));
Requires.NotNull(satisfyingExports, nameof(satisfyingExports));
Requires.NotNull(requiredSharingBoundaries, nameof(requiredSharingBoundaries));
#if DEBUG // These checks are expensive. Don't do them in production.
// Make sure we have entries for every import.
Requires.Argument(satisfyingExports.Count == definition.Imports.Count() && definition.Imports.All(d => satisfyingExports.ContainsKey(d)), "satisfyingExports", Strings.ExactlyOneEntryForEveryImport);
Requires.Argument(satisfyingExports.All(kv => kv.Value != null), "satisfyingExports", Strings.AllValuesMustBeNonNull);
#endif
this.Definition = definition;
this.SatisfyingExports = satisfyingExports;
this.RequiredSharingBoundaries = requiredSharingBoundaries;
}
static public bool IsSubsetOf <TKey, TValue>(this IReadOnlyDictionary <TKey, TValue> _this, IReadOnlyDictionary <TKey, TValue> other, IEqualityComparer <TKey> keyComparer, IEqualityComparer <TValue> valueComparer)
{
return(_this.All
(
x =>
{
if (!other.ContainsKey(x.Key))
{
return false;
}
else
{
var otherVal = other[x.Key];
return valueComparer.Equals(x.Value, otherVal);
}
}
));
}
public static bool HasTags(this IResource resource, IReadOnlyDictionary <string, string> tags)
{
return(tags.All(t => resource.HasTag(t.Key, t.Value)));
}
public static bool KeysEquals <TK, TV>(this IReadOnlyDictionary <TK, TV> first, IReadOnlyDictionary <TK, TV> second) => first.All(kvp => second.ContainsKey(kvp.Key)) && second.All(kvp => first.ContainsKey(kvp.Key));
public static bool Equals <TK, TV>(this IReadOnlyDictionary <TK, TV> first, IReadOnlyDictionary <TK, TV> second) => first.All(kvp => second.ContainsKey(kvp.Key) && second[kvp.Key].Equals(kvp.Value)) && second.All(kvp => first.ContainsKey(kvp.Key) && first[kvp.Key].Equals(kvp.Value));
public static ParserResult Parse(string file)
{
ParserResult result = new();
var lines = File.ReadAllLines(file);
for (var index = 0; index < lines.Length; index++)
{
var line = lines[index];
if (string.IsNullOrEmpty(line))
{
continue;
}
if (line.StartsWith("КОММЕНТАРИЙ:"))
{
continue;
}
if (InstructionTypes.All(i => !line.StartsWith(i.Key)))
{
Program.WriteError($"\nfile: {file}\nline {index + 1}: unknown instruction.");
Environment.Exit(1);
}
else
{
var name = InstructionTypes.First(i => line.StartsWith(i.Key));
var ins = (Instruction)Activator.CreateInstance(name.Value) !;
ins.Parameters = line.Split(" ").Skip(1).ToList();
ins.Line = index;
ins.PrepareForExecution();
var check = ins.CheckValid(line);
if (check == "valid")
{
result.Instructions.Add(ins);
}
else
{
Program.WriteError($"\nfile: {file}\nline {index + 1}: {check}");
Environment.Exit(1);
}
}
}
foreach (var variable in from instruction in result.Instructions.ToList() where instruction is Create && instruction.Parameters[0] == "ПЕРЕМЕННУЮ" select _parseVariable(ref result.Instructions, instruction) into variable where variable != null select variable)
{
if (variable != null)
{
result.Variables.Add(variable);
}
}
foreach (var method in from instruction in result.Instructions.ToList()
where instruction is Create && instruction.Parameters[0] == "МЕТОД"
select _parseMethod(ref result.Instructions, instruction)
into method
where method != null
select method)
{
if (method != null)
{
result.Methods.Add(method);
}
}
foreach (var @class in from instruction in result.Instructions.ToList()
where instruction is Create && instruction.Parameters[0] == "КЛАСС"
select new AnatoliyClass())
{
var createLine = result.Instructions.First(i => i is Create && i.Parameters[0] == "КЛАСС");
var end = result.Instructions.First(i => i.Line > createLine.Line && i is End);
foreach (var m in result.Methods)
{
@class.Methods.Add(m.Name, m);
}
@class.Namespace = createLine.Parameters[2];
@class.Name = createLine.Parameters[1];
result.Classes.Add(@class);
var endIndex = end.Line == result.Instructions.Count ? end.Line : end.Line + 1;
_removeInstructionFrom(ref result.Instructions, createLine.Line, endIndex);
}
return(result);
}
public MimeTypeProvider(IReadOnlyDictionary<string, string> mimeTypesByExtension)
{
if (!mimeTypesByExtension.All(x => x.Key.StartsWith(".")))
throw new Exception("The keys in the dictionary needs to all start with a '.'");
this.mimeTypesByExtension = mimeTypesByExtension.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase);
}