private IWriteHandler CheckBaseTypes(Type type, IEnumerable<Type> baseTypes) { IDictionary<Type, IWriteHandler> possibles = new Dictionary<Type, IWriteHandler>(); foreach (Type item in baseTypes) { // TODO Better way to decide the most appropriate possibility if (possibles.Count < 1) { IWriteHandler h; if (handlers.TryGetValue(item, out h)) { possibles.Add(item, h); } } } switch (possibles.Count) { case 0: return null; case 1: { IWriteHandler h = possibles.First().Value; handlers = handlers.Add(type, h); return h; } default: throw new TransitException("More thane one match for " + type); } }
public static void Add(RecursiveAsyncLock mutex, Task<IDisposable> key) { Tuple<int, Task<IDisposable>> value; if (!OwnedLocks.TryGetValue(mutex, out value)) value = Tuple.Create(0, key); OwnedLocks = OwnedLocks.SetItem(mutex, Tuple.Create(value.Item1 + 1, value.Item2)); }
public ReferencesEventArgs(int contextId, ReferencesMessage message) : base(contextId) { _root = message.RootDependency; _dependencies = message.Dependencies.Select(kvp => new KeyValuePair<string, Package>( kvp.Key, new Package(message.LongFrameworkName, kvp.Value))).ToImmutableDictionary(); }
protected Statement(IImmutableDictionary<Id, Id> attributes) { if (attributes == null) { throw new ArgumentNullException("attributes"); } this.attributes = attributes; }
public NodeStatement(Id id, IImmutableDictionary<Id, Id> attributes) : base(attributes) { if (id == null) { throw new ArgumentNullException("id"); } this.id = id; }
public Build(string id, string number, IImmutableDictionary<PackageVersionId, Package> createdPackages, IImmutableDictionary<PackageVersionId, Package> dependencies) { CreatedPackages = createdPackages; Dependencies = dependencies; Id = id; Number = number; }
/// <summary> /// Initializes a new instance of the <see cref="AbstractParser"/> class. /// </summary> /// <param name="handlers">The handlers.</param> /// <param name="defaultHandler">The default handler.</param> /// <param name="dictionaryBuilder">The dictionary builder.</param> /// <param name="listBuilder">The list builder.</param> protected AbstractParser(IImmutableDictionary<string, IReadHandler> handlers, IDefaultReadHandler<object> defaultHandler, IDictionaryReader dictionaryBuilder, IListReader listBuilder) { this.handlers = handlers; this.defaultHandler = defaultHandler; this.dictionaryBuilder = (IDictionaryReader)dictionaryBuilder; this.listBuilder = (IListReader)listBuilder; }
/// <summary> /// Initializes a new instance of the <see cref="JsonParser"/> class. /// </summary> /// <param name="jsonTextReader">The json text reader.</param> /// <param name="handlers">The handlers.</param> /// <param name="defaultHandler">The default handler.</param> /// <param name="dictionaryBuilder">The dictionary builder.</param> /// <param name="listBuilder">The list builder.</param> public JsonParser( JsonTextReader jsonTextReader, IImmutableDictionary<string, IReadHandler> handlers, IDefaultReadHandler<object> defaultHandler, IDictionaryReader dictionaryBuilder, IListReader listBuilder) : base(handlers, defaultHandler, dictionaryBuilder, listBuilder) { this.jp = jsonTextReader; }
public static void Remove(RecursiveAsyncLock mutex) { var value = OwnedLocks[mutex]; if (value.Item1 == 1) { OwnedLocks = OwnedLocks.Remove(mutex); value.Item2.Result.Dispose(); } else { OwnedLocks = OwnedLocks.SetItem(mutex, Tuple.Create(value.Item1 - 1, value.Item2)); } }
/// <summary> /// Initializes a new instance of the <see cref="ParReader"/> class based on the specified stream and using ASCII encoding. /// </summary> /// <param name="output">The output stream.</param> /// <param name="leaveOpen">true to leave the stream open after the <see cref="ParWriter"/> object is disposed; otherwise, false.</param> public ParWriter(Stream output, bool leaveOpen) : base(output, Encoding.ASCII, leaveOpen) { var origin = BaseStream.Position; BaseStream.Seek(0, SeekOrigin.Begin); if (output.CanRead && output.CanSeek) { using (var reader = new BinaryReader(output, Encoding.ASCII, true)) { while (BaseStream.Position < BaseStream.Length) { int b; do { b = BaseStream.ReadByte(); if (b == 'P') { byte[] buffer = new byte[8]; BaseStream.Read(buffer, 1, 7); buffer[0] = (byte)b; if (Encoding.UTF8.GetString(buffer) == "PAR2\0PKT") { var pos = BaseStream.Position - 8; var ok = Verify(reader); var end = BaseStream.Position; if (ok) { BaseStream.Seek(pos + 8, SeekOrigin.Begin); packets = packets.Add(pos, reader.ReadInt64()); BaseStream.Seek(end, SeekOrigin.Begin); } else { BaseStream.Seek(pos + 1, SeekOrigin.Begin); } } } } while (b != 'P'); } } BaseStream.Seek(origin, SeekOrigin.Begin); } }
public EdgeStatement(NodeId fromId, NodeId toId, IImmutableDictionary<Id, Id> attributes) : base(attributes) { if (fromId == null) { throw new ArgumentNullException("fromId"); } if (toId == null) { throw new ArgumentNullException("toId"); } this.fromId = fromId; this.toId = toId; }
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 Configuration(XContainer xml) { var settings = xml .Descendants("Setting") .Select(e => { var keyElement = e.Element("Key"); var valueElement = e.Element("Value"); if (valueElement != null && keyElement != null) { return new { Key = keyElement.Value, Value = valueElement.Value }; } return null; }) .Where(e => e != null) .ToImmutableDictionary(e => e.Key, e => e.Value); IgnoreHeaderComments = "true".Equals(settings["sonar.cs.ignoreHeaderComments"]); Files = xml.Descendants("File").Select(e => e.Value).ToImmutableList(); AnalyzerIds = xml.Descendants("Rule").Select(e => e.Elements("Key").Single().Value).ToImmutableHashSet(); var builder = ImmutableDictionary.CreateBuilder<string, List<IImmutableDictionary<string, string>>>(); foreach (var rule in xml.Descendants("Rule").Where(e => e.Elements("Parameters").Any())) { var analyzerId = rule.Elements("Key").Single().Value; var parameters = rule .Elements("Parameters").Single() .Elements("Parameter") .ToImmutableDictionary(e => e.Elements("Key").Single().Value, e => e.Elements("Value").Single().Value); if (!builder.ContainsKey(analyzerId)) { builder.Add(analyzerId, new List<IImmutableDictionary<string, string>>()); } builder[analyzerId].Add(parameters); } Parameters = builder.ToImmutable(); }
/// <summary> /// Initializes a new instance of the <see cref="ParReader"/> class based on the specified stream and using ASCII encoding, and optionally leaves the stream open. /// </summary> /// <param name="input">The input stream.</param> /// <param name="leaveOpen">true to leave the stream open after the <see cref="ParReader"/> object is disposed; otherwise, false.</param> public ParReader(Stream input, bool leaveOpen) : base(input, Encoding.ASCII, leaveOpen) { var origin = BaseStream.Position; BaseStream.Seek(0, SeekOrigin.Begin); while (BaseStream.Position < BaseStream.Length) { int b; do { b = BaseStream.ReadByte(); if (b == 'P') { byte[] buffer = new byte[8]; BaseStream.Read(buffer, 1, 7); buffer[0] = (byte)b; if (Encoding.UTF8.GetString(buffer) == "PAR2\0PKT") { var pos = BaseStream.Position - 8; var ok = Verify(); var end = BaseStream.Position; if (ok) { BaseStream.Seek(pos + 48, SeekOrigin.Begin); var type = this.ReadBytes(16); BaseStream.Seek(end, SeekOrigin.Begin); packets = packets.Add(pos, new PacketType(type)); } else { BaseStream.Seek(pos + 1, SeekOrigin.Begin); } } } } while (b != 'P'); } BaseStream.Seek(origin, SeekOrigin.Begin); }
/// <summary> /// Creates a new instance of the SyntaxTreeGeneratorData class /// </summary> /// <param name="ilGenerator">The IL generator</param> /// <param name="symbolTable">The symbol table</param> public SyntaxTreeGeneratorData(ILGenerator ilGenerator, IImmutableDictionary<string, Symbol> symbolTable) { this.ILGenerator = ilGenerator; this.SymbolTable = symbolTable; }
private NormalChildrenContainer(IImmutableDictionary<string, IChildStats> children) : base(children) { }
public ImmutableInbox(IImmutableDictionary<StuffId, ImmutableStuff> dict) { _dict = dict; }
public Bucket(Address owner, long version, IImmutableDictionary<string, ValueHolder> content) : this() { Owner = owner; Version = version; Content = content; }
internal PackageResolver(IImmutableDictionary<string, ImmutableArray<string>> map) { _map = map; }
public static void DictionaryOfList() { const string JsonString = @"{""Key1"":[1,2],""Key2"":[3,4]}"; { IDictionary obj = JsonSerializer.Parse <IDictionary>(JsonString); Assert.Equal(2, obj.Count); int expectedNumber = 1; JsonElement element = (JsonElement)obj["Key1"]; foreach (JsonElement value in element.EnumerateArray()) { Assert.Equal(expectedNumber++, value.GetInt32()); } element = (JsonElement)obj["Key2"]; foreach (JsonElement value in element.EnumerateArray()) { Assert.Equal(expectedNumber++, value.GetInt32()); } string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); } { IDictionary <string, List <int> > obj = JsonSerializer.Parse <IDictionary <string, List <int> > >(JsonString); Assert.Equal(2, obj.Count); Assert.Equal(2, obj["Key1"].Count); Assert.Equal(1, obj["Key1"][0]); Assert.Equal(2, obj["Key1"][1]); Assert.Equal(2, obj["Key2"].Count); Assert.Equal(3, obj["Key2"][0]); Assert.Equal(4, obj["Key2"][1]); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); } { ImmutableDictionary <string, List <int> > obj = JsonSerializer.Parse <ImmutableDictionary <string, List <int> > >(JsonString); Assert.Equal(2, obj.Count); Assert.Equal(2, obj["Key1"].Count); Assert.Equal(1, obj["Key1"][0]); Assert.Equal(2, obj["Key1"][1]); Assert.Equal(2, obj["Key2"].Count); Assert.Equal(3, obj["Key2"][0]); Assert.Equal(4, obj["Key2"][1]); string json = JsonSerializer.ToString(obj); const string ReorderedJsonString = @"{""Key2"":[3,4],""Key1"":[1,2]}"; Assert.True(JsonString == json || ReorderedJsonString == json); } { IImmutableDictionary <string, List <int> > obj = JsonSerializer.Parse <IImmutableDictionary <string, List <int> > >(JsonString); Assert.Equal(2, obj.Count); Assert.Equal(2, obj["Key1"].Count); Assert.Equal(1, obj["Key1"][0]); Assert.Equal(2, obj["Key1"][1]); Assert.Equal(2, obj["Key2"].Count); Assert.Equal(3, obj["Key2"][0]); Assert.Equal(4, obj["Key2"][1]); string json = JsonSerializer.ToString(obj); const string ReorderedJsonString = @"{""Key2"":[3,4],""Key1"":[1,2]}"; Assert.True(JsonString == json || ReorderedJsonString == json); } }
public static void DictionaryOfString() { const string JsonString = @"{""Hello"":""World"",""Hello2"":""World2""}"; const string ReorderedJsonString = @"{""Hello2"":""World2"",""Hello"":""World""}"; { IDictionary obj = JsonSerializer.Parse <IDictionary>(JsonString); Assert.Equal("World", ((JsonElement)obj["Hello"]).GetString()); Assert.Equal("World2", ((JsonElement)obj["Hello2"]).GetString()); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); json = JsonSerializer.ToString <object>(obj); Assert.Equal(JsonString, json); } { Dictionary <string, string> obj = JsonSerializer.Parse <Dictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); json = JsonSerializer.ToString <object>(obj); Assert.Equal(JsonString, json); } { SortedDictionary <string, string> obj = JsonSerializer.Parse <SortedDictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); json = JsonSerializer.ToString <object>(obj); Assert.Equal(JsonString, json); } { IDictionary <string, string> obj = JsonSerializer.Parse <IDictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); json = JsonSerializer.ToString <object>(obj); Assert.Equal(JsonString, json); } { IReadOnlyDictionary <string, string> obj = JsonSerializer.Parse <IReadOnlyDictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); json = JsonSerializer.ToString <object>(obj); Assert.Equal(JsonString, json); } { ImmutableDictionary <string, string> obj = JsonSerializer.Parse <ImmutableDictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.True(JsonString == json || ReorderedJsonString == json); json = JsonSerializer.ToString <object>(obj); Assert.True(JsonString == json || ReorderedJsonString == json); } { IImmutableDictionary <string, string> obj = JsonSerializer.Parse <IImmutableDictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.True(JsonString == json || ReorderedJsonString == json); json = JsonSerializer.ToString <object>(obj); Assert.True(JsonString == json || ReorderedJsonString == json); } { ImmutableSortedDictionary <string, string> obj = JsonSerializer.Parse <ImmutableSortedDictionary <string, string> >(JsonString); Assert.Equal("World", obj["Hello"]); Assert.Equal("World2", obj["Hello2"]); string json = JsonSerializer.ToString(obj); Assert.True(JsonString == json); json = JsonSerializer.ToString <object>(obj); Assert.True(JsonString == json); } { Hashtable obj = JsonSerializer.Parse <Hashtable>(JsonString); Assert.Equal("World", ((JsonElement)obj["Hello"]).GetString()); Assert.Equal("World2", ((JsonElement)obj["Hello2"]).GetString()); string json = JsonSerializer.ToString(obj); Assert.True(JsonString == json || ReorderedJsonString == json); json = JsonSerializer.ToString <object>(obj); Assert.True(JsonString == json || ReorderedJsonString == json); } { SortedList obj = JsonSerializer.Parse <SortedList>(JsonString); Assert.Equal("World", ((JsonElement)obj["Hello"]).GetString()); Assert.Equal("World2", ((JsonElement)obj["Hello2"]).GetString()); string json = JsonSerializer.ToString(obj); Assert.Equal(JsonString, json); json = JsonSerializer.ToString <object>(obj); Assert.Equal(JsonString, json); } }
internal static int CountShards(IImmutableDictionary <IActorRef, IImmutableList <string> > allocations) { return(CountShardsPerRegion(allocations).Sum()); }
internal static ImmutableList <int> CountShardsPerRegion(IImmutableDictionary <IActorRef, IImmutableList <string> > newAllocations) { return(newAllocations.Values.Select(i => i.Count).ToImmutableList()); }
public void SetCommands(IImmutableDictionary <string, CommandBase> commands) { this.commands = commands; }
public CommandExecutor(TextReader inIO = null, TextWriter outIO = null) { this.commands = new Dictionary <string, CommandBase>().ToImmutableDictionary(); _inIO = inIO ?? Console.In; _outIO = outIO ?? Console.Out; }
protected abstract void AddToContext(string fullPath, IImmutableDictionary <string, string> metadata, bool isActiveContext, IProjectLogger logger);
public AbstractEmitter(IImmutableDictionary<Type, IWriteHandler> handlers) { this.handlers = handlers; }
public async Task ReconcileAsync(CancellationToken token) { DeploymentStatus status = DeploymentStatus.Unknown; ModuleSet moduleSetToReport = null; using (await this.reconcileLock.LockAsync(token)) { try { Events.StartingReconcile(); (ModuleSet current, DeploymentConfigInfo deploymentConfigInfo, Exception exception) = await this.GetReconcileData(token); moduleSetToReport = current; if (exception != null) { ExceptionDispatchInfo.Capture(exception).Throw(); } DeploymentConfig deploymentConfig = deploymentConfigInfo.DeploymentConfig; if (deploymentConfig.Equals(DeploymentConfig.Empty)) { status = DeploymentStatus.Success; } else { ModuleSet desiredModuleSet = deploymentConfig.GetModuleSet(); _ = Task.Run(() => this.availabilityMetric.ComputeAvailability(desiredModuleSet, current)) .ContinueWith(t => Events.UnknownFailure(t.Exception), TaskContinuationOptions.OnlyOnFaulted) .ConfigureAwait(false); // TODO - Update this logic to create identities only when needed, in the Command factory, instead of creating all the identities // up front here. That will allow handling the case when only the state of the system has changed (say one module crashes), and // no new identities need to be created. This will simplify the logic to allow EdgeAgent to work when offline. // But that required ModuleSet.Diff to be updated to include modules updated by deployment, and modules updated by state change. IImmutableDictionary <string, IModuleIdentity> identities = await this.moduleIdentityLifecycleManager.GetModuleIdentitiesAsync(desiredModuleSet, current); Plan plan = await this.planner.PlanAsync(desiredModuleSet, current, deploymentConfig.Runtime, identities); if (plan.IsEmpty) { status = DeploymentStatus.Success; } else { try { bool result = await this.planRunner.ExecuteAsync(deploymentConfigInfo.Version, plan, token); await this.UpdateCurrentConfig(deploymentConfigInfo); if (result) { status = DeploymentStatus.Success; } } catch (Exception ex) when(!ex.IsFatal()) { Events.PlanExecutionFailed(ex); await this.UpdateCurrentConfig(deploymentConfigInfo); throw; } } } } catch (Exception ex) when(!ex.IsFatal()) { switch (ex) { case ConfigEmptyException _: status = new DeploymentStatus(DeploymentStatusCode.ConfigEmptyError, ex.Message); Events.EmptyConfig(ex); break; case InvalidSchemaVersionException _: status = new DeploymentStatus(DeploymentStatusCode.InvalidSchemaVersion, ex.Message); Events.InvalidSchemaVersion(ex); break; case ConfigFormatException _: status = new DeploymentStatus(DeploymentStatusCode.ConfigFormatError, ex.Message); Events.InvalidConfigFormat(ex); break; default: status = new DeploymentStatus(DeploymentStatusCode.Failed, ex.Message); Events.UnknownFailure(ex); break; } } await this.reporter.ReportAsync(token, moduleSetToReport, await this.environment.GetRuntimeInfoAsync(), this.currentConfig.Version, status); Events.FinishedReconcile(); } }
public JsonVerboseEmitter(JsonWriter jsonWriter, IImmutableDictionary<Type, IWriteHandler> handlers) : base(jsonWriter, handlers) { }
/// <summary> /// Visits the entire tree, calling <see cref="IProjectTreePropertiesProvider.CalculatePropertyValues(IProjectTreeCustomizablePropertyContext, IProjectTreeCustomizablePropertyValues)"/> /// for every node. /// </summary> public static IProjectTree ChangePropertyValuesForEntireTree(this IProjectTreePropertiesProvider propertiesProvider, IProjectTree tree, IImmutableDictionary <string, string>?projectTreeSettings = null) { // Cheat here, because the IProjectTree that we get from ProjectTreeParser is mutable, we want to clone it // so that any properties providers changes don't affect the "original" tree. If we implemented a completely // immutable tree, then we wouldn't have to do that - but that's currently a lot of work for test-only purposes. string treeAsString = ProjectTreeWriter.WriteToString(tree); return(ChangePropertyValuesWalkingTree(propertiesProvider, ProjectTreeParser.Parse(treeAsString), projectTreeSettings)); }
private async Task<long> NextTagSequenceNr(string tag) { long value; if (!_tagSequenceNr.TryGetValue(tag, out value)) { value = await ReadHighestSequenceNrAsync(TagId(tag), 0L); } value++; _tagSequenceNr = _tagSequenceNr.SetItem(tag, value); return value; }
private static IProjectTree ChangePropertyValuesWalkingTree(IProjectTreePropertiesProvider propertiesProvider, IProjectTree tree, IImmutableDictionary <string, string>?projectTreeSettings) { tree = ChangePropertyValues(propertiesProvider, tree, projectTreeSettings); foreach (IProjectTree child in tree.Children) { tree = ChangePropertyValuesWalkingTree(propertiesProvider, child, projectTreeSettings).Parent !; } return(tree); }
/// <summary> /// Caches the write. /// </summary> /// <param name="s">The s.</param> /// <param name="asDictionaryKey">if set to <c>true</c> [as dictionary key].</param> /// <returns></returns> public string CacheWrite(string s, bool asDictionaryKey) { if (enabled && IsCacheable(s, asDictionaryKey)) { string val; if (cache.TryGetValue(s, out val)) { return val; } else { if (index == MaxCacheEntries) { Init(); } cache = cache.SetItem(s, IndexToCode(index++)); } } // TODO Either s or val is returned. Weird?! return s; }
private static IProjectTree ChangePropertyValues(IProjectTreePropertiesProvider propertiesProvider, IProjectTree child, IImmutableDictionary <string, string>?projectTreeSettings) { var propertyContextAndValues = new ProjectTreeCustomizablePropertyContextAndValues(child, projectTreeSettings); propertiesProvider.CalculatePropertyValues(propertyContextAndValues, propertyContextAndValues); return(propertyContextAndValues.Tree); }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { if (LongValueSemanticsProvider.IsAdaptedType(type)) { var result = reflector.LoadSpecification(LongValueSemanticsProvider.AdaptedType, metamodel); metamodel = result.Item2; var spec = result.Item1 as IObjectSpecImmutable; AddValueFacets(new LongValueSemanticsProvider(spec, specification), specification); } return(metamodel); }
public ProjectTreeCustomizablePropertyContextAndValues(IProjectTree tree, IImmutableDictionary <string, string>?projectTreeSettings) { _tree = tree; ProjectTreeSettings = projectTreeSettings ?? ImmutableDictionary <string, string> .Empty; }
protected abstract void UpdateInContext(string fullPath, IImmutableDictionary <string, string> previousMetadata, IImmutableDictionary <string, string> currentMetadata, bool isActiveContext, IProjectLogger logger);
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { var attribute = type.GetCustomAttribute <MultiLineAttribute>(); FacetUtils.AddFacet(Create(attribute, specification)); return(metamodel); }
public static IChildrenContainer Create(IImmutableDictionary<string, IChildStats> children) { if (children.Count == 0) return EmptyChildrenContainer.Instance; return new NormalChildrenContainer(children); }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, MethodInfo method, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { Process(method, specification); return(metamodel); }
/// <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); }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { if (property.GetGetMethod() != null && TypeUtils.IsString(property.PropertyType)) { Process(property, specification); } return(metamodel); }
/// <summary> /// Applies the specified version of the project evaluation <see cref="IProjectChangeDiff"/> and metadata to the underlying /// <see cref="IWorkspaceProjectContext"/>, indicating if the context is the currently active one. /// </summary> /// <exception cref="ArgumentNullException"> /// <paramref name="version"/> is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="difference" /> is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="previousMetadata" /> is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="currentMetadata" /> is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="logger" /> is <see langword="null"/>. /// </exception> public void ApplyProjectEvaluation(IComparable version, IProjectChangeDiff difference, IImmutableDictionary <string, IImmutableDictionary <string, string> > previousMetadata, IImmutableDictionary <string, IImmutableDictionary <string, string> > currentMetadata, bool isActiveContext, IProjectLogger logger) { Requires.NotNull(version, nameof(version)); Requires.NotNull(difference, nameof(difference)); Requires.NotNull(previousMetadata, nameof(previousMetadata)); Requires.NotNull(currentMetadata, nameof(currentMetadata)); Requires.NotNull(logger, nameof(logger)); if (!difference.AnyChanges) { return; } difference = HandlerServices.NormalizeRenames(difference); EnqueueProjectEvaluation(version, difference); ApplyChangesToContext(difference, previousMetadata, currentMetadata, isActiveContext, logger, evaluation: true); }
public override IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { ParameterInfo parameter = method.GetParameters()[paramNum]; if (TypeUtils.IsString(parameter.ParameterType)) { var attribute = parameter.GetCustomAttribute <MultiLineAttribute>(); FacetUtils.AddFacet(Create(attribute, holder)); } return(metamodel); }
public AttributeStatement(AttributeKinds attributeKind, IImmutableDictionary<Id, Id> attributes) : base(attributes) { this.attributeKind = attributeKind; }
public static string GenerateCompoundDurationTimex(Dictionary <string, string> unitToTimexComponents, IImmutableDictionary <string, long> unitValueMap) { var unitList = new List <string>(unitToTimexComponents.Keys); unitList.Sort((x, y) => (unitValueMap[x] < unitValueMap[y] ? 1 : -1)); var isTimeDurationAlreadyExist = false; var timexBuilder = new StringBuilder(Constants.GeneralPeriodPrefix); for (int i = 0; i < unitList.Count; i++) { var timexComponent = unitToTimexComponents[unitList[i]]; // The Time Duration component occurs first time, if (!isTimeDurationAlreadyExist && IsTimeDurationTimex(timexComponent)) { timexBuilder.Append($"{Constants.TimeTimexPrefix}{GetDurationTimexWithoutPrefix(timexComponent)}"); isTimeDurationAlreadyExist = true; } else { timexBuilder.Append($"{GetDurationTimexWithoutPrefix(timexComponent)}"); } } return(timexBuilder.ToString()); }
public JsonEmitter(JsonWriter jsonWriter, IImmutableDictionary<Type, IWriteHandler> handlers) : base(handlers) { this.jsonWriter = jsonWriter; }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { if (!StringValueSemanticsProvider.IsAdaptedType(type)) { return(metamodel); } var(oSpec, mm) = reflector.LoadSpecification <IObjectSpecImmutable>(StringValueSemanticsProvider.AdaptedType, metamodel); AddValueFacets(new StringValueSemanticsProvider(oSpec, specification), specification); return(mm); }
private async Task <Dictionary <DocumentId, DocumentStateChecksums> > GetDocumentMapAsync <T>(Project project, IImmutableDictionary <DocumentId, T> states, HashSet <Checksum> documents) where T : TextDocumentState { var map = new Dictionary <DocumentId, DocumentStateChecksums>(); foreach (var kv in states) { var documentChecksums = await kv.Value.GetStateChecksumsAsync(_cancellationToken).ConfigureAwait(false); if (documents.Contains(documentChecksums.Checksum)) { map.Add(kv.Key, documentChecksums); } } return(map); }
protected override void LoadPlainValueInternal(IImmutableDictionary <string, IValue> plainValue) { avatarAddress = plainValue["avatarAddress"].ToAddress(); slotIndex = plainValue["slotIndex"].ToInteger(); }
public DiagramOperationResult( [NotNull] IImmutableDictionary <ModelNodeId, IDiagramNode> nodes, [NotNull] IImmutableDictionary <ModelRelationshipId, IDiagramConnector> connectors) : this(nodes, connectors, ImmutableList.Create <DiagramShapeEventBase>()) { }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { var method = FindMethod(reflector, type, MethodType.Class, RecognisedMethodsAndPrefixes.MenuMethod, null, null); if (method != null) { RemoveMethod(methodRemover, method); FacetUtils.AddFacet(new MenuFacetViaMethod(method, specification)); } else { FacetUtils.AddFacet(new MenuFacetDefault(specification)); } return(metamodel); }
public IImmutableDictionary <string, ITypeSpecBuilder> IntrospectType(Type typeToIntrospect, ITypeSpecImmutable specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) => throw new NotImplementedException();
public async Task <IRule?> GetBrowseObjectRuleAsync(IDependency dependency, IProjectCatalogSnapshot?catalogs) { Requires.NotNull(dependency, nameof(dependency)); IImmutableDictionary <string, IPropertyPagesCatalog> namedCatalogs = await GetNamedCatalogsAsync(); Requires.NotNull(namedCatalogs, nameof(namedCatalogs)); if (!namedCatalogs.TryGetValue(PropertyPageContexts.BrowseObject, out IPropertyPagesCatalog browseObjectsCatalog)) { // Issue https://github.com/dotnet/project-system/issues/4860 suggests this code path // can exist, however a repro was not found to dig deeper into the underlying cause. // For now just return null as the upstream caller handles null correctly anyway. return(null); } Rule?schema = browseObjectsCatalog.GetSchema(dependency.SchemaName); string itemSpec = string.IsNullOrEmpty(dependency.OriginalItemSpec) ? dependency.Path : dependency.OriginalItemSpec; var context = ProjectPropertiesContext.GetContext( UnconfiguredProject, itemType: dependency.SchemaItemType, itemName: itemSpec); if (schema == null) { // Since we have no browse object, we still need to create *something* so // that standard property pages can pop up. Rule emptyRule = RuleExtensions.SynthesizeEmptyRule(context.ItemType); return(GetConfiguredProjectExports().PropertyPagesDataModelProvider.GetRule( emptyRule, context.File, context.ItemType, context.ItemName)); } if (dependency.Resolved) { return(GetConfiguredProjectExports().RuleFactory.CreateResolvedReferencePageRule( schema, context, dependency.Name, dependency.BrowseObjectProperties)); } return(browseObjectsCatalog.BindToContext(schema.Name, context)); async Task <IImmutableDictionary <string, IPropertyPagesCatalog> > GetNamedCatalogsAsync() { if (catalogs != null) { return(catalogs.NamedCatalogs); } if (_namedCatalogs == null) { Assumes.NotNull(ActiveConfiguredProject); Assumes.Present(ActiveConfiguredProject.Services.PropertyPagesCatalog); // Note: it is unlikely that we end up here, however for cases when node providers // getting their node data not from Design time build events, we might have OnDependenciesChanged // event coming before initial design time build event updates NamedCatalogs in this class. // Thus, just in case, explicitly request it here (GetCatalogsAsync will acquire a project read lock) _namedCatalogs = await ActiveConfiguredProject.Services.PropertyPagesCatalog.GetCatalogsAsync(); } return(_namedCatalogs); } ConfiguredProjectExports GetConfiguredProjectExports() { Assumes.NotNull(ActiveConfiguredProject); ConfiguredProject project = dependency.TargetFramework.Equals(TargetFramework.Any) ? ActiveConfiguredProject : _dependenciesSnapshotProvider.GetConfiguredProject(dependency.TargetFramework) ?? ActiveConfiguredProject; return(GetActiveConfiguredProjectExports(project)); } }
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]; }
private void ApplyChangesToContext(IProjectChangeDiff difference, IImmutableDictionary <string, IImmutableDictionary <string, string> > previousMetadata, IImmutableDictionary <string, IImmutableDictionary <string, string> > currentMetadata, bool isActiveContext, IProjectLogger logger, bool evaluation) { foreach (string includePath in difference.RemovedItems) { RemoveFromContextIfPresent(includePath, logger); } foreach (string includePath in difference.AddedItems) { AddToContextIfNotPresent(includePath, currentMetadata, isActiveContext, logger); } if (evaluation) { // No need to look at metadata for design-time builds, the items that come from // that aren't traditional items, but are just command-line args we took from // the compiler and converted them to look like items. foreach (string includePath in difference.ChangedItems) { UpdateInContextIfPresent(includePath, previousMetadata, currentMetadata, isActiveContext, logger); } } Assumes.True(difference.RenamedItems.Count == 0, "We should have normalized renames."); }
/// <summary> /// Initializes this instance. /// </summary> /// <returns>The write cache.</returns> public WriteCache Init() { index = 0; cache = cache.Clear(); return this; }
public Task ClearAsync() { _cache = _cache.Clear(); return Task.FromResult(true); }
public AggregateAnalysisDetail(AggregateAnalysisDetailAnalysis analysis, string job, string workItem, IImmutableDictionary <string, string> key) { Analysis = analysis; Job = job; WorkItem = workItem; Key = key; }
private void UpdateInContextIfPresent(string includePath, IImmutableDictionary <string, IImmutableDictionary <string, string> > previousMetadata, IImmutableDictionary <string, IImmutableDictionary <string, string> > currentMetadata, bool isActiveContext, IProjectLogger logger) { string fullPath = _project.MakeRooted(includePath); if (_paths.Contains(fullPath)) { IImmutableDictionary <string, string> previousItemMetadata = previousMetadata.GetValueOrDefault(includePath, ImmutableStringDictionary <string> .EmptyOrdinal); IImmutableDictionary <string, string> currentItemMetadata = currentMetadata.GetValueOrDefault(includePath, ImmutableStringDictionary <string> .EmptyOrdinal); UpdateInContext(fullPath, previousItemMetadata, currentItemMetadata, isActiveContext, logger); } }