public ProductionItem( MarkedProduction markedProduction, IReadOnlySet <Terminal <TTokenKind> > lookaheads) { MarkedProduction = markedProduction; Lookaheads = lookaheads ?? Set <Terminal <TTokenKind> > .Empty; }
internal AsyncMethodToStateMachineRewriter( MethodSymbol method, int methodOrdinal, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, IReadOnlySet <Symbol> hoistedVariables, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, DiagnosticBag diagnostics) : base(F, method, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics, useFinalizerBookkeeping: false) { _method = method; _asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; _asyncMethodBuilderField = builder; _exprReturnLabel = F.GenerateLabel("exprReturn"); _exitLabel = F.GenerateLabel("exitLabel"); _exprRetValue = method.IsGenericTaskReturningAsync(F.Compilation) ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, syntax: F.Syntax, kind: SynthesizedLocalKind.AsyncMethodReturnValue) : null; _dynamicFactory = new LoweredDynamicOperationFactory(F, methodOrdinal); _awaiterFields = new Dictionary <TypeSymbol, FieldSymbol>(TypeSymbol.EqualsIgnoringDynamicAndTupleNamesComparer); _nextAwaiterId = slotAllocatorOpt?.PreviousAwaiterSlotCount ?? 0; }
public BoolResult UpdateAll(IReadOnlyList <MachineId> activeMachines, IReadOnlySet <MachineId> inactiveMachines) { try { lock (_lockObject) { // Remove active machines that became inactive or disappeared. var machinesToRemove = _machinesToBinsMap.Keys.Except(activeMachines).ToList(); foreach (var machine in activeMachines) { AddLocation(machine); } foreach (var machine in inactiveMachines.Concat(machinesToRemove)) { RemoveLocation(machine); } } return(BoolResult.Success); } catch (Exception e) { return(new BoolResult(e, $"{nameof(BinManager)}.{nameof(UpdateAll)} failed.")); } }
internal AsyncMethodToStateMachineRewriter( MethodSymbol method, int methodOrdinal, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, IReadOnlySet<Symbol> hoistedVariables, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, DiagnosticBag diagnostics) : base(F, method, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics, useFinalizerBookkeeping: false) { _method = method; _asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; _asyncMethodBuilderField = builder; _exprReturnLabel = F.GenerateLabel("exprReturn"); _exitLabel = F.GenerateLabel("exitLabel"); _exprRetValue = method.IsGenericTaskReturningAsync(F.Compilation) ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, syntax: F.Syntax, kind: SynthesizedLocalKind.AsyncMethodReturnValue) : null; _dynamicFactory = new LoweredDynamicOperationFactory(F, methodOrdinal); _awaiterFields = new Dictionary<TypeSymbol, FieldSymbol>(TypeSymbol.EqualsIgnoringDynamicComparer); _nextAwaiterId = slotAllocatorOpt?.PreviousAwaiterSlotCount ?? 0; }
public Rule(IEnumerable <Chain> chains, NonTerminalSymbol target) { if (chains == null) { throw new ArgumentNullException(nameof(chains)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } Chains = chains.ToSortedSet().AsReadOnly(); if (!Chains.Any()) { throw new ArgumentException("Rule must contain at least one chain."); } if (Chains.AnyNull()) { throw new ArgumentException("At least one null chain was found."); } Alphabet = Chains.SelectMany(chain => chain.Alphabet).ToSortedSet().AsReadOnly(); Target = target; ISet <NonTerminalSymbol> nonTerminals = Chains.SelectMany(chain => chain.NonTerminals).ToSortedSet(); nonTerminals.Add(Target); NonTerminals = nonTerminals.AsReadOnly(); }
private async Task <bool> EvaluateAllFilesAsync(IReadOnlySet <AbsolutePath> evaluationGoals, QualifierId qualifierId) { // TODO: consider revisiting this and keeping track of individually evaluated projects, so partial // evaluation is possible Contract.Assert(m_rushWorkspaceResolver.ComputedProjectGraph.Succeeded); RushGraphResult result = m_rushWorkspaceResolver.ComputedProjectGraph.Result; // TODO add support for qualifiers IReadOnlySet <RushProject> filteredBuildFiles = result.RushGraph.Projects .Where(project => evaluationGoals.Contains(project.ProjectPath(m_context.PathTable))) .ToReadOnlySet(); var pipConstructor = new RushPipConstructor(m_context, m_host, result.ModuleDefinition, m_rushResolverSettings, m_rushWorkspaceResolver.UserDefinedEnvironment, m_rushWorkspaceResolver.UserDefinedPassthroughVariables); var graphConstructor = new ProjectGraphToPipGraphConstructor <RushProject>(pipConstructor, m_host.Configuration.FrontEnd.MaxFrontEndConcurrency()); var scheduleResult = await graphConstructor.TrySchedulePipsForFilesAsync(filteredBuildFiles, qualifierId); return(scheduleResult.Succeeded); }
protected BoundStatement Rewrite() { if (this.body.HasErrors) { return(this.body); } F.OpenNestedType(stateMachineType); GenerateControlFields(); // fields for the initial values of all the parameters of the method if (PreserveInitialParameterValues) { initialParameters = new Dictionary <Symbol, CapturedSymbolReplacement>(); } // fields for the captured variables of the method var variablesToHoist = IteratorAndAsyncCaptureWalker.Analyze(F.Compilation, method, body, diagnostics); CreateNonReusableLocalProxies(variablesToHoist, out this.nonReusableLocalProxies, out this.nextFreeHoistedLocalSlot); this.hoistedVariables = variablesToHoist; GenerateMethodImplementations(); // Return a replacement body for the kickoff method return(GenerateKickoffMethodBody()); }
/// <summary> /// Initializes a new instance of the <see cref="AbstractAreaOfInterest{TKey, TInterest}" /> class. /// </summary> /// <param name="map">The interest map to add and remove interests from.</param> /// <param name="interest">The interest to add and remove.</param> /// <param name="observableOrigin">The origin of the area of interest to follow.</param> /// <param name="keys">The keys of the cells to apply interests to.</param> public AbstractAreaOfInterest( IInterestMap <TKey, TInterest> map, TInterest interest, IObservable <TKey> observableOrigin, IReadOnlySet <TKey> keys) { Contracts.Requires.That(map != null); Contracts.Requires.That(observableOrigin != null); Contracts.Requires.That(keys != null); this.map = map; this.interest = interest; this.keys = keys; IObservable <TKey> firstKey, lastKey; var pairKeys = observableOrigin.TakeUntil(this.disposed).PairWithPrevious(out firstKey, out lastKey); this.subscriptions = new AggregateDisposable( pairKeys.Subscribe( origin => this.map.UpdateInterests( this.interest, addTo: this.GetKeys(origin.Next), removeFrom: this.GetKeys(origin.Previous))), firstKey.Subscribe( origin => this.map.AddInterests(this.interest, this.GetKeys(origin))), lastKey.Subscribe( origin => this.map.RemoveInterests(this.interest, this.GetKeys(origin)), () => this.Dispose())); }
internal AsyncIteratorMethodToStateMachineRewriter(MethodSymbol method, int methodOrdinal, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, AsyncIteratorInfo asyncIteratorInfo, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, IReadOnlySet <Symbol> hoistedVariables, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, ArrayBuilder <StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, BindingDiagnosticBag diagnostics) : base(method, methodOrdinal, asyncMethodBuilderMemberCollection, F, state, builder, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics) { Debug.Assert(asyncIteratorInfo != null); _asyncIteratorInfo = asyncIteratorInfo; _currentDisposalLabel = _exprReturnLabel; _exprReturnLabelTrue = F.GenerateLabel("yieldReturn"); _iteratorStateAllocator = new ResumableStateMachineStateAllocator( slotAllocatorOpt, firstState: StateMachineStates.FirstResumableAsyncIteratorState, increasing: false); }
protected BoundStatement Rewrite() { if (this.body.HasErrors) { return(this.body); } F.OpenNestedType(stateMachineType); GenerateControlFields(); // fields for the initial values of all the parameters of the method if (PreserveInitialParameterValues) { initialParameters = new Dictionary <Symbol, CapturedSymbolReplacement>(); } // fields for the captured variables of the method var variablesCaptured = IteratorAndAsyncCaptureWalker.Analyze(compilationState.ModuleBuilderOpt.Compilation, method, body); this.nonReusableLocalProxies = CreateNonReusableLocalProxies(variablesCaptured); this.variablesCaptured = variablesCaptured; GenerateMethodImplementations(); // Return a replacement body for the original method return(ReplaceOriginalMethod()); }
public MetaTransition( IEnumerable <Label> metaCurrentRequiredStates, IEnumerable <Label> metaCurrentOptionalStates, char symbol, IEnumerable <Label> metaNextStates) { if (metaCurrentRequiredStates == null) { throw new ArgumentNullException(nameof(metaCurrentRequiredStates)); } if (metaCurrentOptionalStates == null) { throw new ArgumentNullException(nameof(metaCurrentOptionalStates)); } if (metaNextStates == null) { throw new ArgumentNullException(nameof(metaNextStates)); } CurrentOptionalStates = metaCurrentOptionalStates.ToSortedSet().AsReadOnly(); CurrentRequiredStates = metaCurrentRequiredStates.ToSortedSet().AsReadOnly(); NextStates = metaNextStates.ToSortedSet().AsReadOnly(); Symbol = symbol; }
public ErrorState( IReadOnlySet <object> previousState, IEnumerable <Exception> errors) { State = previousState; Errors = errors; }
private static IReadOnlySet <Point> FlipTiles(IReadOnlySet <Point> tiles) { var newTiles = new HashSet <Point>(); var neighbours = CalculateNeighbours(tiles); foreach (var tile in tiles) { var allNeighbours = neighbours[tile]; var activeNeighbours = allNeighbours.Intersect(tiles).Count(); if (activeNeighbours != 0 && activeNeighbours <= 2) { newTiles.Add(tile); } } foreach (var tile in neighbours.SelectMany(x => x.Value).Distinct().Except(tiles)) { if (tiles.Count(tile.IsNeighbour) == 2) { newTiles.Add(tile); } } return(newTiles); }
static int CountNeighbors(IReadOnlySet <HyperCube> actives, int x, int y, int z, int w) { int count = 0; for (int xx = x - 1; xx <= x + 1; xx++) { for (int yy = y - 1; yy <= y + 1; yy++) { for (int zz = z - 1; zz <= z + 1; zz++) { for (int ww = w - 1; ww <= w + 1; ww++) { if (x == xx & y == yy && z == zz && w == ww) { continue; } if (actives.Contains(new HyperCube(xx, yy, zz, ww))) { count++; } } } } } return(count); }
public MethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, IReadOnlySet <Symbol> variablesCaptured, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, DiagnosticBag diagnostics, bool useFinalizerBookkeeping) : base(F.CompilationState, diagnostics) { Debug.Assert(F != null); Debug.Assert(originalMethod != null); Debug.Assert(state != null); Debug.Assert(nonReusableLocalProxies != null); Debug.Assert(diagnostics != null); Debug.Assert(variablesCaptured != null); this.F = F; this.stateField = state; this.cachedState = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32), kind: SynthesizedLocalKind.StateMachineCachedState); this.useFinalizerBookkeeping = useFinalizerBookkeeping; this.hasFinalizerState = useFinalizerBookkeeping; this.originalMethod = originalMethod; this.variablesCaptured = variablesCaptured; foreach (var proxy in nonReusableLocalProxies) { this.proxies.Add(proxy.Key, proxy.Value); } }
private static void SetIfSelected(string sectionName, IReadOnlySet <string> sections, Action setDashboardAction) { if (sections.Contains(sectionName)) { setDashboardAction(); } }
private Task <bool> EvaluateAllFilesAsync(IReadOnlySet <AbsolutePath> evaluationGoals, QualifierId qualifierId) { Contract.Assert(m_msBuildWorkspaceResolver.ComputedProjectGraph.Succeeded); ProjectGraphResult result = m_msBuildWorkspaceResolver.ComputedProjectGraph.Result; GlobalProperties qualifier = MsBuildResolverUtils.CreateQualifierAsGlobalProperties(qualifierId, m_context); IReadOnlySet <ProjectWithPredictions> filteredBuildFiles = result.ProjectGraph.ProjectNodes .Where(project => evaluationGoals.Contains(project.FullPath)) .Where(project => ProjectMatchesQualifier(project, qualifier)) .ToReadOnlySet(); var graphConstructor = new PipGraphConstructor( m_context, m_host, result.ModuleDefinition, m_msBuildResolverSettings, result.MsBuildLocation, result.DotNetExeLocation, m_frontEndName, m_msBuildWorkspaceResolver.UserDefinedEnvironment, m_msBuildWorkspaceResolver.UserDefinedPassthroughVariables); return(graphConstructor.TrySchedulePipsForFilesAsync(filteredBuildFiles, qualifierId)); }
/********* ** Private methods *********/ /// <summary>Draw borders for each unconnected edge of a tile.</summary> /// <param name="spriteBatch">The sprite batch being drawn.</param> /// <param name="group">The machine group.</param> /// <param name="tile">The group tile.</param> /// <param name="color">The border color.</param> private void DrawEdgeBorders(SpriteBatch spriteBatch, IMachineGroup group, Vector2 tile, Color color) { int borderSize = 3; float screenX = tile.X * Game1.tileSize - Game1.viewport.X; float screenY = tile.Y * Game1.tileSize - Game1.viewport.Y; float tileSize = Game1.tileSize; IReadOnlySet <Vector2> tiles = group.GetTiles(this.LocationKey); // top if (!tiles.Contains(new Vector2(tile.X, tile.Y - 1))) { spriteBatch.DrawLine(screenX, screenY, new Vector2(tileSize, borderSize), color); // top } // bottom if (!tiles.Contains(new Vector2(tile.X, tile.Y + 1))) { spriteBatch.DrawLine(screenX, screenY + tileSize, new Vector2(tileSize, borderSize), color); // bottom } // left if (!tiles.Contains(new Vector2(tile.X - 1, tile.Y))) { spriteBatch.DrawLine(screenX, screenY, new Vector2(borderSize, tileSize), color); // left } // right if (!tiles.Contains(new Vector2(tile.X + 1, tile.Y))) { spriteBatch.DrawLine(screenX + tileSize, screenY, new Vector2(borderSize, tileSize), color); // right } }
public DependencyResolutionModel(IEnumerable <IVh <IDependencyHandler2> > handlerChainSource = default) { if (handlerChainSource is null) { _handlerChain = new IVh <IDependencyHandler2> [0]; _handlerUniqueSet = SetReadOnlyWrap <IDependencyHandler2> .Empty; } else { var effectiveHandlerChain = new List <IVh <IDependencyHandler2> >(); var handlerUniqueSet = new HashSet <IDependencyHandler2>(comparer: ReferenceEqualityComparer <IDependencyHandler2> .Instance); var indexCounter = -1; foreach (var handlerVh in handlerChainSource) { indexCounter++; var handler = handlerVh.Arg($"{nameof(handlerChainSource)}[{indexCounter:d}]").EnsureSelfAndValueNotNull().Value.Value; if (handlerUniqueSet.Add(item: handler)) { effectiveHandlerChain.Add(handlerVh); } } _handlerChain = effectiveHandlerChain.ToArray(); _handlerUniqueSet = new SetReadOnlyWrap <IDependencyHandler2>(set: handlerUniqueSet); } }
/// <summary> /// Constructs a constraint that will enforce that the given <paramref name="squares"/> are /// magic squares based on the rows, columns, and, optionally, the diagonals. /// </summary> /// <param name="possibleValues"> /// The possible values that can be in the magic squares. /// </param> /// <param name="squares"> /// The locations of the magic squares. /// </param> /// <param name="includeDiagonals"> /// If true, values along the diagonals of the square must also sum to the magic number. /// </param> /// <exception cref="ArgumentException"> /// If the any of the given <paramref name="squares"/>' sizes are not compatible with the /// length of <paramref name="possibleValues"/>. /// </exception> public MagicSquaresConstraint(ReadOnlySpan <int> possibleValues, IEnumerable <Box> squares, bool includeDiagonals = true) { _size = possibleValues.Length; _magicSquares = squares.ToArray(); _squareSize = Boxes.IntSquareRoot(_size); _includeDiagonals = includeDiagonals; if (_magicSquares.Any( b => b.TopLeft.Row < 0 || b.TopLeft.Column < 0 || b.TopLeft.Row + b.Size > _size || b.TopLeft.Column + b.Size > _size || b.Size != _squareSize)) { throw new ArgumentException( $"Based on the {nameof(possibleValues)}, {nameof(squares)} must fit in a puzzle of size {_size} and have size {_squareSize}."); } _allPossibleValues = new BitVector(); for (int i = 0; i < possibleValues.Length; ++i) { if (_allPossibleValues.IsBitSet(possibleValues[i])) { throw new ArgumentException("Values must be unique."); } _allPossibleValues.SetBit(possibleValues[i]); } _possibleSets = MagicSquares.ComputeSets(possibleValues, _squareSize, _allPossibleValues); }
public SCG.IReadOnlyDictionary <Guid, bool> TestPacketIdsAreNew(IReadOnlySet <Guid> queryIds) { return(queryIds.ToDictionary( q => q, seenIds.TryAdd)); // var results = new SCG.Dictionary<Guid, bool>(); // // HashSet<Guid> newIdCandidates = new HashSet<Guid>(); // foreach (var queryId in queryIds) { // if (seenIds.Contains(queryId)) { // results[queryId] = false; // } else { // newIdCandidates.Add(queryId); // } // } // // lock (synchronization) { // var nextSeenIds = new HashSet<Guid>(seenIds); // foreach (var queryId in newIdCandidates) { // results[queryId] = nextSeenIds.Add(queryId); // } // seenIds = nextSeenIds; // } // // return results; }
public Task <SCG.IReadOnlyDictionary <K, Entry <K, V> > > GetManyAsync(IReadOnlySet <K> keys) { return(ExecCommandAsync(async cmd => { // Retrieve all rows cmd.CommandText = $"SELECT * FROM {tableName} WHERE id=ANY(@ids)"; var idParameter = cmd.CreateParameter(); idParameter.ParameterName = "ids"; idParameter.Value = keys.ToArray(); cmd.Parameters.Add(idParameter); using (var reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false)) { var results = new SCG.Dictionary <K, Entry <K, V> >(); while (await reader.ReadAsync().ConfigureAwait(false)) { var entry = ReadToEntry(reader); results[entry.Key] = entry; } foreach (var key in keys) { if (!results.ContainsKey(key)) { results[key] = Entry <K, V> .CreateNonexistant(key); } } return (SCG.IReadOnlyDictionary <K, Entry <K, V> >)results; } })); }
internal IteratorMethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, FieldSymbol current, IReadOnlySet <Symbol> hoistedVariables, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, BindingDiagnosticBag diagnostics ) : base( F, originalMethod, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics, useFinalizerBookkeeping: false ) { _current = current; }
public MethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, IReadOnlySet<Symbol> variablesCaptured, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, DiagnosticBag diagnostics, bool useFinalizerBookkeeping) : base(F.CompilationState, diagnostics) { Debug.Assert(F != null); Debug.Assert(originalMethod != null); Debug.Assert(state != null); Debug.Assert(nonReusableLocalProxies != null); Debug.Assert(diagnostics != null); Debug.Assert(variablesCaptured != null); this.F = F; this.stateField = state; this.cachedState = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32), kind: SynthesizedLocalKind.StateMachineCachedState); this.useFinalizerBookkeeping = useFinalizerBookkeeping; this.hasFinalizerState = useFinalizerBookkeeping; this.originalMethod = originalMethod; this.variablesCaptured = variablesCaptured; foreach (var proxy in nonReusableLocalProxies) { this.proxies.Add(proxy.Key, proxy.Value); } }
internal AsyncMethodToStateMachineRewriter( MethodSymbol method, int methodOrdinal, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, IReadOnlySet <Symbol> hoistedVariables, IReadOnlyDictionary <Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, ArrayBuilder <StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, BindingDiagnosticBag diagnostics) : base(F, method, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics) { _method = method; _asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; _asyncMethodBuilderField = builder; _exprReturnLabel = F.GenerateLabel("exprReturn"); _exitLabel = F.GenerateLabel("exitLabel"); _exprRetValue = method.IsAsyncEffectivelyReturningGenericTask(F.Compilation) ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, syntax: F.Syntax, kind: SynthesizedLocalKind.AsyncMethodReturnValue) : null; _dynamicFactory = new LoweredDynamicOperationFactory(F, methodOrdinal); _awaiterFields = new Dictionary <TypeSymbol, FieldSymbol>(Symbols.SymbolEqualityComparer.IgnoringDynamicTupleNamesAndNullability); _nextAwaiterId = slotAllocatorOpt?.PreviousAwaiterSlotCount ?? 0; _placeholderMap = new Dictionary <BoundValuePlaceholderBase, BoundExpression>(); }
private async Task <EvaluationResult> CollectProjectOutputsAsync(IReadOnlySet <AbsolutePath> evaluationGoals, QualifierId qualifierId, ResolvedJavaScriptExport export, IEvaluationScheduler scheduler) { // Make sure all project files are evaluated before collecting their outputs if (!await EvaluateAllFilesOnceAsync(evaluationGoals, qualifierId, scheduler)) { return(EvaluationResult.Error); } var processOutputs = export.ExportedProjects.SelectMany(project => { if (!m_scheduledProcessOutputs.TryGetValue(project, out var projectOutputs)) { // The requested project was not scheduled. This can happen when a filter gets applied, so even // though the export points to a valid project (which is already validated), the project is not part // of the graph. In this case just log an informational message. Tracing.Logger.Log.RequestedExportIsNotPresent( Context.LoggingContext, m_resolverSettings.Location(Context.PathTable), export.FullSymbol.ToString(Context.SymbolTable), project.Name, project.ScriptCommandName); } return(projectOutputs); }); // Let's put together all output directories for all pips under this project var sealedDirectories = processOutputs.SelectMany(process => process.GetOutputDirectories().Select(staticDirectory => new EvaluationResult(staticDirectory))).ToArray(); return(new EvaluationResult(new EvaluatedArrayLiteral(sealedDirectories, default, m_javaScriptWorkspaceResolver.ExportsFile)));
internal Pseudograph( IReadOnlySet <T> vertices, IReadOnlyCollection <E> edges) { this.Vertices = vertices; this.Edges = edges; }
/// <summary> /// Initializes a new instance of the <see cref="CharacterClass"/> class. /// </summary> /// <param name="characters">The characters in the character set.</param> public CharacterClass(IReadOnlySet<Character> characters) { #region Contract Contract.Requires<ArgumentNullException>(characters != null); #endregion this.Characters = characters; }
public void ThrowIfIllegal(IReadOnlySet <Argument> arguments) { HashSet <char> characters = new HashSet <char>(); foreach (Argument argument in arguments) { if (argument.ShortNames.Count < 1) { throw new ArgumentException( "POSIX-style parsing requires that arguments have at least one short name."); } foreach (string shortName in argument.ShortNames) { if (shortName.Length > 1) { throw new ArgumentException( "POSIX-style parsing requires that short names be only one character long."); } char character = shortName[0]; if (character == '-') { throw new ArgumentException( "POSIX-style parsing requires short names not start with '-'."); } if (!characters.Add(character)) { throw new ArgumentException( "POSIX-style parsing requires that short names have a unique first character."); } } } }
public void CalculationTest(IReadOnlySet <object> result, string expression, Parser parser) { var tokens = expression.Split().Append(string.Empty); var set = new StateMachine(parser).Calculate(tokens); Assert.True(result.SetEquals(set)); }
public ParseResult Parse( IReadOnlySet <Argument> arguments, IReadOnlyList <string> values) => MsBuildParser .StateMachine .Run(() => new SharedState(arguments, values)) .Results .ToParseResult();
public async Task <bool> GrantRolesAsync(ulong userId, IReadOnlySet <DiscordRole> discordRoles) { DiscordGuild guild = await _guildProvider.GetCurrentGuildAsync(); List <DRole> roles = new(); foreach (DiscordRole discordRole in discordRoles) { DRole?role = guild.GetRole(discordRole.RoleId); if (role == null) { _logger.LogWarning("Couldn't map all roles. Please verify your config file"); return(false); } roles.Add(role); } // TODO: job queue Task _ = Task.Run(async() => { DiscordMember member = await guild.GetMemberAsync(userId); foreach (DRole role in roles) { await member.GrantRoleAsync(role, "Auth"); } }); return(true); }
/// <nodoc /> public SandboxedProcessPipExecutionResult( SandboxedProcessPipExecutionStatus status, SortedReadOnlyArray <ObservedFileAccess, ObservedFileAccessExpandedPathComparer> observedFileAccesses, IReadOnlyDictionary <AbsolutePath, IReadOnlyCollection <FileArtifactWithAttributes> > sharedDynamicDirectoryWriteAccesses, Tuple <AbsolutePath, Encoding> encodedStandardOutput, Tuple <AbsolutePath, Encoding> encodedStandardError, int numberOfWarnings, FileAccessReportingContext unexpectedFileAccesses, ProcessTimes primaryProcessTimes, JobObject.AccountingInformation?jobAccountingInformation, int exitCode, long sandboxPrepMs, long processSandboxedProcessResultMs, long processStartTime, IReadOnlyList <ReportedFileAccess> allReportedFileAccesses, IReadOnlyList <ProcessDetouringStatusData> detouringStatuses, long maxDetoursHeapSize, ContainerConfiguration containerConfiguration, Dictionary <string, int> pipProperties, bool timedOut, IReadOnlySet <AbsolutePath> createdDirectories, RetryInfo retryInfo = null) { Contract.Requires(!ProcessCompletedExecution(status) || observedFileAccesses.IsValid); Contract.Requires(!ProcessCompletedExecution(status) || unexpectedFileAccesses != null); Contract.Requires(!ProcessCompletedExecution(status) || primaryProcessTimes != null); Contract.Requires(encodedStandardOutput == null || (encodedStandardOutput.Item1.IsValid && encodedStandardOutput.Item2 != null)); Contract.Requires(encodedStandardError == null || (encodedStandardError.Item1.IsValid && encodedStandardError.Item2 != null)); Contract.Requires(numberOfWarnings >= 0); Contract.Requires(containerConfiguration != null); Contract.Requires(retryInfo == null || status != SandboxedProcessPipExecutionStatus.Succeeded); // Protect against invalid combinations of RetryLocation and RetryReason Contract.Requires(!retryInfo.CanBeRetriedInlineOrFalseIfNull() || retryInfo.RetryReason != RetryReason.ResourceExhaustion); Contract.Requires(!retryInfo.CanBeRetriedInlineOrFalseIfNull() || retryInfo.RetryReason != RetryReason.ProcessStartFailure); Contract.Requires(!retryInfo.CanBeRetriedInlineOrFalseIfNull() || retryInfo.RetryReason != RetryReason.TempDirectoryCleanupFailure); Contract.Requires(!retryInfo.CanBeRetriedInlineOrFalseIfNull() || retryInfo.RetryReason != RetryReason.StoppedWorker); Status = status; ObservedFileAccesses = observedFileAccesses; UnexpectedFileAccesses = unexpectedFileAccesses; EncodedStandardOutput = encodedStandardOutput; EncodedStandardError = encodedStandardError; NumberOfWarnings = numberOfWarnings; PrimaryProcessTimes = primaryProcessTimes; JobAccountingInformation = jobAccountingInformation; ExitCode = exitCode; SandboxPrepMs = sandboxPrepMs; ProcessSandboxedProcessResultMs = processSandboxedProcessResultMs; ProcessStartTimeMs = processStartTime; AllReportedFileAccesses = allReportedFileAccesses; DetouringStatuses = detouringStatuses; MaxDetoursHeapSizeInBytes = maxDetoursHeapSize; SharedDynamicDirectoryWriteAccesses = sharedDynamicDirectoryWriteAccesses; ContainerConfiguration = containerConfiguration; PipProperties = pipProperties; TimedOut = timedOut; RetryInfo = retryInfo; CreatedDirectories = createdDirectories ?? CollectionUtilities.EmptySet <AbsolutePath>(); }
public SCG.IReadOnlyDictionary<Guid, bool> TestPacketIdsAreNew(IReadOnlySet<Guid> queryIds) { return queryIds.ToDictionary( q => q, seenIds.TryAdd); // var results = new SCG.Dictionary<Guid, bool>(); // // HashSet<Guid> newIdCandidates = new HashSet<Guid>(); // foreach (var queryId in queryIds) { // if (seenIds.Contains(queryId)) { // results[queryId] = false; // } else { // newIdCandidates.Add(queryId); // } // } // // lock (synchronization) { // var nextSeenIds = new HashSet<Guid>(seenIds); // foreach (var queryId in newIdCandidates) { // results[queryId] = nextSeenIds.Add(queryId); // } // seenIds = nextSeenIds; // } // // return results; }
private int nextFinalizeState = StateMachineStates.FinishedStateMachine - 1; // -3 internal IteratorMethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, FieldSymbol current, IReadOnlySet<Symbol> variablesCaptured, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> initialProxies, DiagnosticBag diagnostics) : base(F, originalMethod, state, variablesCaptured, initialProxies, diagnostics, useFinalizerBookkeeping: false) { this.current = current; }
private int _nextFinalizeState = StateMachineStates.FinishedStateMachine - 1; // -3 internal IteratorMethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, FieldSymbol current, IReadOnlySet<Symbol> hoistedVariables, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, DiagnosticBag diagnostics) : base(F, originalMethod, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics, useFinalizerBookkeeping: false) { _current = current; }
public CommonCompiler(CommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader) { IEnumerable<string> allArgs = args; _clientDirectory = clientDirectory; Debug.Assert(null == responseFile || PathUtilities.IsAbsolute(responseFile)); if (!SuppressDefaultResponseFile(args) && File.Exists(responseFile)) { allArgs = new[] { "@" + responseFile }.Concat(allArgs); } this.Arguments = parser.Parse(allArgs, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories); this.MessageProvider = parser.MessageProvider; this.AssemblyLoader = assemblyLoader; this.EmbeddedSourcePaths = GetEmbedddedSourcePaths(Arguments); if (Arguments.ParseOptions.Features.ContainsKey("debug-determinism")) { EmitDeterminismKey(Arguments, args, baseDirectory, parser); } }
internal AsyncMethodToStateMachineRewriter( MethodSymbol method, AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection, SyntheticBoundNodeFactory F, FieldSymbol state, FieldSymbol builder, IReadOnlySet<Symbol> variablesCaptured, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, DiagnosticBag diagnostics) : base(F, method, state, variablesCaptured, nonReusableLocalProxies, diagnostics, useFinalizerBookkeeping: false) { this.method = method; this.asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection; this.asyncMethodBuilderField = builder; this.exprReturnLabel = F.GenerateLabel("exprReturn"); this.exitLabel = F.GenerateLabel("exitLabel"); this.exprRetValue = method.IsGenericTaskReturningAsync(F.Compilation) ? F.SynthesizedLocal(asyncMethodBuilderMemberCollection.ResultType, kind: SynthesizedLocalKind.AsyncMethodReturnValue) : null; this.dynamicFactory = new LoweredDynamicOperationFactory(F); }
// new: public MethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, IReadOnlySet<Symbol> hoistedVariables, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, DiagnosticBag diagnostics, bool useFinalizerBookkeeping) : base(slotAllocatorOpt, F.CompilationState, diagnostics) { Debug.Assert(F != null); Debug.Assert(originalMethod != null); Debug.Assert(state != null); Debug.Assert(nonReusableLocalProxies != null); Debug.Assert(diagnostics != null); Debug.Assert(hoistedVariables != null); Debug.Assert(nextFreeHoistedLocalSlot >= 0); this.F = F; this.stateField = state; this.cachedState = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32), syntax: F.Syntax, kind: SynthesizedLocalKind.StateMachineCachedState); _useFinalizerBookkeeping = useFinalizerBookkeeping; _hasFinalizerState = useFinalizerBookkeeping; this.OriginalMethod = originalMethod; _hoistedVariables = hoistedVariables; _synthesizedLocalOrdinals = synthesizedLocalOrdinals; _nextFreeHoistedLocalSlot = nextFreeHoistedLocalSlot; foreach (var proxy in nonReusableLocalProxies) { this.proxies.Add(proxy.Key, proxy.Value); } // create cache local for reference type "this" in Release var thisParameter = originalMethod.ThisParameter; CapturedSymbolReplacement thisProxy; if ((object)thisParameter != null && thisParameter.Type.IsReferenceType && proxies.TryGetValue(thisParameter, out thisProxy) && F.Compilation.Options.OptimizationLevel == OptimizationLevel.Release) { BoundExpression thisProxyReplacement = thisProxy.Replacement(F.Syntax, frameType => F.This()); this.cachedThis = F.SynthesizedLocal(thisProxyReplacement.Type, syntax: F.Syntax, kind: SynthesizedLocalKind.FrameCache); } }
public async Task<IRyuContainer> CreateAsync(IReadOnlySet<ITransportFactory> transportFactories, Guid? forceId = null) { var container = root.CreateChildContainer(); var proxyGenerator = container.GetOrDefault<ProxyGenerator>() ?? new ProxyGenerator(); var shutdownCancellationTokenSource = new CancellationTokenSource(); // Auditing Subsystem var auditService = new AuditService(shutdownCancellationTokenSource.Token); auditService.Initialize(); // management tier containers var mobContextContainer = new MobContextContainer(); var mobContextFactory = new MobContextFactory(auditService); var mobOperations = new MobOperations(mobContextFactory, mobContextContainer); // Other Courier Stuff var identity = Identity.Create(forceId); var routingTable = new RoutingTable(); var peerDiscoveryEventBus = new AsyncBus<PeerDiscoveryEvent>(); var peerTable = new PeerTable(container, (table, peerId) => new PeerContext(table, peerId, peerDiscoveryEventBus)); var inboundMessageRouter = new InboundMessageRouter(); var inboundMessageDispatcher = new InboundMessageDispatcher(identity, peerTable, inboundMessageRouter); var transports = new ConcurrentSet<ITransport>(); foreach (var transportFactory in transportFactories) { var transport = await transportFactory.CreateAsync(mobOperations, identity, routingTable, peerTable, inboundMessageDispatcher, auditService).ConfigureAwait(false); transports.TryAdd(transport); } var messenger = new Messenger(identity, transports, routingTable); container.Set(identity); container.Set(routingTable); container.Set(peerTable); container.Set(inboundMessageRouter); container.Set(messenger); //---------------------------------------------------------------------------------------- // Service Tier - Service Discovery, Remote Method Invocation //---------------------------------------------------------------------------------------- var localServiceRegistry = new LocalServiceRegistry(identity, messenger); var remoteServiceInvoker = new RemoteServiceInvoker(identity, messenger); var remoteServiceProxyContainer = new RemoteServiceProxyContainer(proxyGenerator, remoteServiceInvoker); inboundMessageRouter.RegisterHandler<RmiRequestDto>(localServiceRegistry.HandleInvocationRequestAsync); inboundMessageRouter.RegisterHandler<RmiResponseDto>(remoteServiceInvoker.HandleInvocationResponse); container.Set(localServiceRegistry); container.Set(remoteServiceProxyContainer); //---------------------------------------------------------------------------------------- // Management Tier - DMI - Services //---------------------------------------------------------------------------------------- var managementObjectService = new ManagementObjectService(mobContextContainer, mobOperations); localServiceRegistry.RegisterService<IManagementObjectService>(managementObjectService); container.Set(mobOperations); container.Set(managementObjectService); var facade = new CourierFacade(transports, container); container.Set(facade); return container; }
public ProcessSuspensionComponent(IReadOnlySet<string> processNames) { this.processNames = processNames; }
public void Deserialize(IPofReader reader) { processNames = reader.ReadCollection<string, HashSet<string>>(0); }
protected BoundStatement Rewrite() { if (this.body.HasErrors) { return this.body; } F.OpenNestedType(stateMachineClass); GenerateControlFields(); // fields for the initial values of all the parameters of the method if (PreserveInitialParameterValues) { initialParameters = new Dictionary<Symbol, CapturedSymbolReplacement>(); } // fields for the captured variables of the method var variablesCaptured = IteratorAndAsyncCaptureWalker.Analyze(compilationState.ModuleBuilderOpt.Compilation, method, body); this.nonReusableLocalProxies = CreateNonReusableLocalProxies(variablesCaptured); this.variablesCaptured = variablesCaptured; GenerateMethodImplementations(); // Return a replacement body for the original method return ReplaceOriginalMethod(); }
protected BoundStatement Rewrite() { if (this.body.HasErrors) { return this.body; } F.OpenNestedType(stateMachineType); GenerateControlFields(); // fields for the initial values of all the parameters of the method if (PreserveInitialParameterValues) { initialParameters = new Dictionary<Symbol, CapturedSymbolReplacement>(); } // fields for the captured variables of the method var variablesToHoist = IteratorAndAsyncCaptureWalker.Analyze(F.Compilation, method, body, diagnostics); CreateNonReusableLocalProxies(variablesToHoist, out this.nonReusableLocalProxies, out this.nextFreeHoistedLocalSlot); this.hoistedVariables = variablesToHoist; GenerateMethodImplementations(); // Return a replacement body for the kickoff method return GenerateKickoffMethodBody(); }
public ElectionVoteDto(Guid cacheId, Guid nominee, IReadOnlySet<Guid> followers) : base(cacheId) { this.Nominee = nominee; this.Followers = followers; }
protected override void Deserialize(IPofReader reader, int baseSlot) { Nominee = reader.ReadGuid(baseSlot + 0); Followers = reader.ReadCollection<Guid, ItzWarty.Collections.HashSet<Guid>>(baseSlot + 1); }
// new: public MethodToStateMachineRewriter( SyntheticBoundNodeFactory F, MethodSymbol originalMethod, FieldSymbol state, IReadOnlySet<Symbol> hoistedVariables, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies, SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals, VariableSlotAllocator slotAllocatorOpt, int nextFreeHoistedLocalSlot, DiagnosticBag diagnostics, bool useFinalizerBookkeeping) : base(slotAllocatorOpt, F.CompilationState, diagnostics) { Debug.Assert(F != null); Debug.Assert(originalMethod != null); Debug.Assert(state != null); Debug.Assert(nonReusableLocalProxies != null); Debug.Assert(diagnostics != null); Debug.Assert(hoistedVariables != null); Debug.Assert(nextFreeHoistedLocalSlot >= 0); this.F = F; this.stateField = state; this.cachedState = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32), syntax: F.Syntax, kind: SynthesizedLocalKind.StateMachineCachedState); _useFinalizerBookkeeping = useFinalizerBookkeeping; _hasFinalizerState = useFinalizerBookkeeping; this.OriginalMethod = originalMethod; _hoistedVariables = hoistedVariables; _synthesizedLocalOrdinals = synthesizedLocalOrdinals; _nextFreeHoistedLocalSlot = nextFreeHoistedLocalSlot; foreach (var proxy in nonReusableLocalProxies) { this.proxies.Add(proxy.Key, proxy.Value); } }