public CompilationDocument(TextSourceInfo textSourceInfo, IEnumerable <ITextLine> initialTextLines, TypeCobolOptions compilerOptions, IProcessedTokensDocumentProvider processedTokensDocumentProvider, [CanBeNull] MultilineScanState scanState, List <RemarksDirective.TextNameVariation> copyTextNameVariations) { TextSourceInfo = textSourceInfo; CompilerOptions = compilerOptions; CopyTextNamesVariations = copyTextNameVariations ?? new List <RemarksDirective.TextNameVariation>(); MissingCopies = new List <CopyDirective>(); this.processedTokensDocumentProvider = processedTokensDocumentProvider; // Initialize the compilation document lines compilationDocumentLines = ImmutableList <CodeElementsLine> .Empty.ToBuilder(); // ... with the initial list of text lines received as a parameter if (initialTextLines != null) { // Insert Cobol text lines in the internal tree structure compilationDocumentLines.AddRange(initialTextLines.Select(textLine => CreateNewDocumentLine(textLine, textSourceInfo.ColumnsLayout))); } // Initialize document views versions currentTextLinesVersion = new DocumentVersion <ICobolTextLine>(this); currentTokensLinesVersion = new DocumentVersion <ITokensLine>(this); // Initialize performance stats PerfStatsForText = new PerfStatsForCompilationStep(CompilationStep.Text); PerfStatsForScanner = new PerfStatsForCompilationStep(CompilationStep.Scanner); PerfStatsForPreprocessor = new PerfStatsForParsingStep(CompilationStep.Preprocessor); initialScanStateForCopy = scanState; }
/// <summary> /// Creates an asynchronous computation that executes all the given asynchronous computations, initially queueing each as work items and using a fork/join pattern. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="ms"></param> /// <returns></returns> public static Async <ImmutableList <T> > Parallel <T>(this ImmutableList <Async <T> > ms) { var empty = new ImmutableList <T>(); return(() => { var num = (uint)Math.Min(8, ms.Count); // 64 is maximum here if (num == 0) { return empty; } var xs = ms.Take(num); var rest = ms.RemoveRange(0, (int)num); var asyncs = xs.Map(x => { var handle = new AsyncEventHandle <T>(); x.Bind <T, Unit>(v => () => handle.Complete(v)).Start(); return handle; }); WaitHandle.WaitAll(asyncs.Map(ah => (WaitHandle)ah.DoneEvent).ToArray()); var ps = asyncs.Map(x => x.Result()); return empty.AddRange(rest.Count > 0 ? ps.AddRange(rest.Parallel().RunSynchronously()) : ps); }); }
public IImmutableDictionary <TKey, TValue> AddRange(IEnumerable <KeyValuePair <TKey, TValue> > pairs) { return(new ImmutableDictionaryKeepOrder <TKey, TValue>( _dictionary.AddRange(pairs), _items.AddRange(pairs) )); }
IImmutableList <Task> IImmutableList <Task> .AddRange(IEnumerable <Task> items) { return(AttachContinuationTasks(new TaskGroup(this) { _Tasks = _Tasks.AddRange(items) })); }
public Task <ImmutableList <Fact> > Save(FactGraph graph, CancellationToken cancellationToken) { var newFacts = graph.FactReferences .Where(reference => !factsByReference.ContainsKey(reference)) .Select(reference => graph.GetFact(reference)) .ToImmutableList(); factsByReference = factsByReference.AddRange(newFacts .Select(fact => new KeyValuePair <FactReference, Fact>(fact.Reference, fact)) ); var newPredecessors = newFacts .Select(fact => ( factReference: fact.Reference, edges: fact.Predecessors .SelectMany(predecessor => CreateEdges(fact, predecessor)) .ToImmutableList() )) .ToImmutableList(); edges = edges.AddRange(newPredecessors .SelectMany(pair => pair.edges) ); foreach (var(factReference, edges) in newPredecessors) { ancestors = ancestors.Add( factReference, edges .SelectMany(edge => ancestors[edge.Predecessor]) .Append(factReference) .Distinct() .ToImmutableList() ); } return(Task.FromResult(newFacts)); }
private static ImmutableList <string> GetCategoryEntries(ImmutableList <string> urlsToFollow, ImmutableList <string> noFollow = null, ImmutableList <string> entries = null) { if (noFollow == null) { return(GetCategoryEntries(urlsToFollow, ImmutableList.Create <string>())); } if (urlsToFollow.IsEmpty) { return(entries); } var url = urlsToFollow.First(); var remainingUrls = urlsToFollow.Skip(1).ToImmutableList(); var noFollowMore = noFollow.Add(url); var links = LinksFromCategoryPage(url).Except(noFollowMore); if (entries == null) { return(GetCategoryEntries(urlsToFollow, noFollow, ImmutableList.Create <string>())); } var pageEntries = EntriesFromCategory(url); var newEntries = pageEntries.Except(entries); var totalEntries = entries.AddRange(pageEntries); Console.WriteLine("{0} \tpage entries:{1} new:{2} total:{3} new pages:{4} remaining pages:{5}", url, pageEntries.Count(), newEntries.Count(), totalEntries.Count(), links.Count(), remainingUrls.Count()); //if (pageEntries.Where(e => e.Contains(":")).Select(e => { Console.WriteLine(e); return e; }).Count() > 1) //{ // throw new Exception(url + " contains a bad entry"); //} //else Console.WriteLine(); return(GetCategoryEntries(remainingUrls.AddRange(links).Distinct().ToImmutableList(), noFollowMore, totalEntries)); }
// --- Initialization --- /// <summary> /// Initializes a new compilation document from a list of text lines. /// This method does not scan the inserted text lines to produce tokens. /// You must explicitely call UpdateTokensLines() to start an initial scan of the document. /// </summary> public CompilationDocument(TextSourceInfo textSourceInfo, IEnumerable<ITextLine> initialTextLines, TypeCobolOptions compilerOptions, IProcessedTokensDocumentProvider processedTokensDocumentProvider) { TextSourceInfo = textSourceInfo; CompilerOptions = compilerOptions; this.processedTokensDocumentProvider = processedTokensDocumentProvider; // Initialize the compilation document lines compilationDocumentLines = ImmutableList<CodeElementsLine>.Empty.ToBuilder(); // ... with the initial list of text lines received as a parameter if (initialTextLines != null) { // Insert Cobol text lines in the internal tree structure compilationDocumentLines.AddRange(initialTextLines.Select(textLine => CreateNewDocumentLine(textLine, textSourceInfo.ColumnsLayout))); } // Initialize document views versions currentTextLinesVersion = new DocumentVersion<ICobolTextLine>(this); currentTokensLinesVersion = new DocumentVersion<ITokensLine>(this); // Initialize performance stats PerfStatsForText = new PerfStatsForCompilationStep(CompilationStep.Text); PerfStatsForScanner = new PerfStatsForCompilationStep(CompilationStep.Scanner); PerfStatsForPreprocessor = new PerfStatsForCompilationStep(CompilationStep.Preprocessor); }
/// <summary> /// Adds a range of items to the end of the collection. Quicker than adding them individually, /// but the view doesn't update until the last item has been added. /// </summary> public virtual void AddRange(IList <T> items) { DoReadWriteNotify( () => ImmutableList.Count, (index) => ImmutableList.AddRange(items), (index) => new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, (IList)items, index) ); }
public ZipArchiveProblems AddRange(IEnumerable <FileProblem> problems) { if (problems == null) { throw new ArgumentNullException(nameof(problems)); } return(new ZipArchiveProblems(_problems.AddRange(problems))); }
public void AddRange_ReturnsNewListWithNewItemsAppended() { var subject = new ImmutableList<int>(); var result = subject.AddRange(Enumerable.Range(1, 10)); Assert.AreEqual(0, subject.Count); Assert.AreEqual(10, result.Count); }
public void AddRange_ReturnsNewListWithNewItemsAppended() { var subject = new ImmutableList <int>(); var result = subject.AddRange(Enumerable.Range(1, 10)); Assert.AreEqual(0, subject.Count); Assert.AreEqual(10, result.Count); }
public IFileWarningBuilder WithParameters(params ProblemParameter[] parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } return(new FileWarningBuilder(_file, _reason, _parameters.AddRange(parameters))); }
private TargetsToPropagate(ImmutableList <string> outerBuildTargets, ImmutableList <string> nonOuterBuildTargets) { _outerBuildTargets = outerBuildTargets; // This is used as the list of entry targets for both inner builds and non-multitargeting projects // It represents the concatenation of outer build targets and non outer build targets, in this order. // Non-multitargeting projects use these targets because they act as both outer and inner builds. _allTargets = outerBuildTargets.AddRange(nonOuterBuildTargets); }
private IPath <V, E> ComputeNext(IPath <V, E> lastPath) { // Start searching for the next path. for (int i = 0; i < lastPath.Edges.Count; ++i) { V spurNode = lastPath.Edges[i].Src; List <E> rootPathEdgeList = lastPath.Edges.Take(i).ToList(); foreach (IPath <V, E> path in resultPaths) { if (path.Edges.Count >= i && rootPathEdgeList.SequenceEqual(path.Edges.Take(i))) { maskingWeigher.Excluded.Add(path.Edges[i]); } } // Effectively remove all root path nodes other than the spur node. foreach (E edge in rootPathEdgeList) { foreach (E e in graph.GetEdgesFrom(edge.Src)) { maskingWeigher.Excluded.Add(e); } foreach (E e in graph.GetEdgesTo(edge.Src)) { maskingWeigher.Excluded.Add(e); } } IPath <V, E> spurPath = search.Search(graph, spurNode, dst, maskingWeigher, 1).Paths.FirstOrDefault(); if (spurPath != null) { ImmutableList <E> .Builder builder = ImmutableList.CreateBuilder <E>(); builder.AddRange(rootPathEdgeList); builder.AddRange(spurPath.Edges); potentialPaths.Add(Path(builder.ToImmutable())); } // Restore all removed paths and nodes. maskingWeigher.Excluded.Clear(); } return(potentialPaths.IsEmpty ? null : potentialPaths.DeleteMax()); }
public static ulong Part2(string input) { ImmutableList <int> clock = input.Select(x => Convert.ToInt32(x.ToString())).ToImmutableList(); clock = clock.AddRange(Enumerable.Range(10, 1000001 - 10)); var cups = new LinkedList <int>(clock); var res = Run2(cups, 10000000); return(1UL * (ulong)res.NextOrFirst().Value *(ulong)res.NextOrFirst().NextOrFirst().Value); }
private void Tokenize() { // get rid of trimmers first string[] firstpass = file.Split(trimers.ToArray(), StringSplitOptions.RemoveEmptyEntries); // split the text based on list of keywords into tokens foreach (string s in firstpass) { tokens = tokens.AddRange(s.SplitAndKeep(keywords)); } }
protected TInvariant Apply(params object[] evts) { var invariant = this; foreach (var evt in evts) { invariant = Arrange(evt); } invariant._scheduled = _scheduled.AddRange(evts); return((TInvariant)invariant); }
public void Setup() { var range = Enumerable.Range(0, N); immutableList = ImmutableList <int> .Empty; immutableList = immutableList.AddRange(range); trieList = ImmutableTrieList <int> .Empty; trieList = trieList.AddRange(range); list = new List <int>(); list.AddRange(range); }
private static void AddMemberAndAttributes(ImmutableList<SyntaxNode>.Builder elements, SyntaxNode member) { switch (member.Kind()) { case SyntaxKind.ClassDeclaration: case SyntaxKind.StructDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.EnumDeclaration: case SyntaxKindEx.RecordDeclaration: case SyntaxKindEx.RecordStructDeclaration: elements.AddRange(((BaseTypeDeclarationSyntax)member).AttributeLists); break; case SyntaxKind.FieldDeclaration: case SyntaxKind.EventFieldDeclaration: elements.AddRange(((BaseFieldDeclarationSyntax)member).AttributeLists); break; case SyntaxKind.PropertyDeclaration: case SyntaxKind.EventDeclaration: case SyntaxKind.IndexerDeclaration: elements.AddRange(((BasePropertyDeclarationSyntax)member).AttributeLists); break; case SyntaxKind.MethodDeclaration: case SyntaxKind.ConstructorDeclaration: case SyntaxKind.DestructorDeclaration: case SyntaxKind.OperatorDeclaration: case SyntaxKind.ConversionOperatorDeclaration: elements.AddRange(((BaseMethodDeclarationSyntax)member).AttributeLists); break; case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: case SyntaxKind.AddAccessorDeclaration: case SyntaxKind.RemoveAccessorDeclaration: case SyntaxKind.UnknownAccessorDeclaration: elements.AddRange(((AccessorDeclarationSyntax)member).AttributeLists); break; case SyntaxKind.TypeParameter: elements.AddRange(((TypeParameterSyntax)member).AttributeLists); break; case SyntaxKind.Parameter: elements.AddRange(((ParameterSyntax)member).AttributeLists); break; default: break; } elements.Add(member); }
private async Task AddDefinitionEntriesAsync(DefinitionItem definition) { CancellationToken.ThrowIfCancellationRequested(); // Don't do anything if we already have entries for this definition // (i.e. another thread beat us to this). if (HasEntriesForDefinition(definition)) { return; } // First find the bucket corresponding to our definition. If we can't find/create // one, then don't do anything for this reference. var definitionBucket = GetOrCreateDefinitionBucket(definition); if (definitionBucket == null) { return; } // We could do this inside the lock. but that would mean async activity in a // lock, and i'd like to avoid that. That does mean that we might do extra // work if multiple threads end up down htis path. But only one of them will // win when we access the lock below. var builder = ImmutableArray.CreateBuilder <Entry>(); foreach (var definitionLocation in definition.SourceSpans) { var definitionEntry = await CreateDocumentLocationEntryAsync( definitionBucket, definitionLocation, isDefinitionLocation : true).ConfigureAwait(false); if (definitionEntry != null) { builder.Add(definitionEntry); } } lock (_gate) { // Do one final check to ensure that no other thread beat us here. if (!HasEntriesForDefinition(definition)) { _entries = _entries.AddRange(builder); CurrentVersionNumber++; } } // Let all our subscriptions know that we've updated. _tableDataSink.FactorySnapshotChanged(this); }
static ImmutableDictionary <Int32, ImmutableList <Int32> > ToImmutableDictionary(this RepeatedField <PBIntToMultipleIntMap> value) { //# Tested ImmutableDictionary <Int32, ImmutableList <Int32> > .Builder bldr = ImmutableDictionary <Int32, ImmutableList <Int32> > .Empty.ToBuilder(); foreach (PBIntToMultipleIntMap item in value) { ImmutableList <Int32> .Builder l = ImmutableList <int> .Empty.ToBuilder(); l.AddRange(item.Target); bldr.Add(item.Source, l.ToImmutableList()); } return(bldr.ToImmutableDictionary()); }
public void AddState(object?value, string hash, ImmutableSortedSet <string> predecessors) { if (!_predecessors.Contains(hash)) { _candidates = _candidates.Add(new Candidate(hash, value)); _property.SetValue(_object, value); } var newPredecessors = predecessors.Except(_predecessors); _candidates = _candidates.RemoveAll(c => newPredecessors.Contains(c.MessageSignature)); _predecessors = _predecessors.AddRange(predecessors); }
public static ImmutableList <T> AddRange <T>([NotNull] this ImmutableList <T> source, [NotNull] params T[] values) { if (source is null) { throw new ArgumentNullException(nameof(source)); } if (values is null) { throw new ArgumentNullException(nameof(values)); } return(values.Length > 0 ? source.AddRange(values) : source); }
async Task FindTasks(Solution solution, bool raiseTasksChangedEvent = true) { var locator = new TaskRunnerConfigurationLocator(taskRunnerProvider, solution); await locator.FindTasks(); if (locator.GroupedTasks.Any()) { groupedTasks = groupedTasks.AddRange(locator.GroupedTasks); if (raiseTasksChangedEvent) { OnTasksChanged(); } } }
public static ImmutableList <IPropertySymbol> GetPropertySymbolsBaseLevels(this INamedTypeSymbol namedTypeSymbol, bool includeOnlyLowerLevelPropertiesFromInterfaces) { if (includeOnlyLowerLevelPropertiesFromInterfaces) { return(namedTypeSymbol.AllInterfaces.SelectMany(x => x.GetPropertySymbols()).ToImmutableList()); } var baseType = namedTypeSymbol.BaseType; ImmutableList <IPropertySymbol> result = ImmutableList.Create <IPropertySymbol>(); while (baseType != null && baseType.Name != "Object") { result = result.AddRange(baseType.GetPropertySymbols()); baseType = baseType.BaseType; } return(result); }
/// <summary> /// A new contact has come in from one of the underlying stores. Update our local database of contacts /// </summary> /// <param name="c"></param> /// <returns></returns> private void UpdateLocalStore(UpdateInfo c) { switch (c._reason) { case UpdateReason.Add: _localContactStore = _localContactStore.AddRange(c._contacts); break; case UpdateReason.Remove: _localContactStore = _localContactStore.RemoveRange(c._contacts); break; default: throw new NotImplementedException(); } }
private async Task AddDeclarationEntriesAsync(DefinitionItem definition) { CancellationToken.ThrowIfCancellationRequested(); // Don't do anything if we already have declaration entries for this definition // (i.e. another thread beat us to this). if (HasDeclarationEntries(definition)) { return; } var definitionBucket = GetOrCreateDefinitionBucket(definition); // We could do this inside the lock. but that would mean async activity in a // lock, and i'd like to avoid that. That does mean that we might do extra // work if multiple threads end up down htis path. But only one of them will // win when we access the lock below. var declarations = ArrayBuilder <Entry> .GetInstance(); foreach (var declarationLocation in definition.SourceSpans) { var definitionEntry = await CreateDocumentLocationEntryAsync( definitionBucket, declarationLocation, isDefinitionLocation : true).ConfigureAwait(false); if (definitionEntry != null) { declarations.Add(definitionEntry); } } lock (_gate) { // Do one final check to ensure that no other thread beat us here. if (!HasDeclarationEntries(definition)) { // We only include declaration entries in the entries we show when // not grouping by definition. _entriesWithDeclarations = _entriesWithDeclarations.AddRange(declarations); CurrentVersionNumber++; } } declarations.Free(); // Let all our subscriptions know that we've updated. _tableDataSink.FactorySnapshotChanged(this); }
public async Task Load() { using (await locker.LockAsync()) { var dbApiItems = await db.ApiItems .Include(x => x.Headers) .Include(x => x.Inputs) .Include(x => x.Outputs) .Include(x => x.Outputs) .Include(x => x.Items) .ToArrayAsync(); var dbApiItemsByParentId = dbApiItems.ToLookup(x => x.CollectionId ?? 0); items = items.AddRange(MapFromDb(dbApiItemsByParentId[0], dbApiItemsByParentId)); } }
public static string ScanLines(TokensLine[] tokensLines) { ImmutableList <TokensLine> .Builder tokensLinesList = ImmutableList <TokensLine> .Empty.ToBuilder(); tokensLinesList.AddRange(tokensLines); ScannerStep.ScanDocument(TextSourceInfo, tokensLinesList, CompilerOptions, CopyTextNameVariations); StringBuilder sbResult = new StringBuilder(); for (int i = 0; i < tokensLines.Length; i++) { sbResult.AppendLine("-- Line " + (i + 1) + " --"); sbResult.AppendLine(BuildResultString(tokensLines[i])); } return(sbResult.ToString()); }
/// <inheritdoc /> public void ReleaseWrite(ImmutableList <T> producedItems) { lock (syncRoot) { if (!writeLocked.HasValue) { throw new InvalidOperationException("Can't release write lock if it is not held"); } else if (producedItems.Count > writeLocked.Value) { throw new InvalidOperationException("Can't write more items than space was locked for"); } else { writeLocked = null; items = items.AddRange(producedItems); CheckWaitingReads(); CheckWaitingWrites(); } } }
/// <summary> /// Creates a new instance of the <see cref="PlayerManagerBuilder"/> /// type. /// </summary> /// <param name="userId"> /// The user ID to perform all connections as. /// </param> /// <param name="services"> /// The service provider to locate any existing services from. /// </param> public PlayerManagerBuilder(ulong userId, IServiceProvider services) { _userId = userId; _loggerFactory = services.GetRequiredService <ILoggerFactory>(); _decoders = ImmutableList.CreateBuilder <IAudioDecoderFactory>(); _providers = ImmutableList.CreateBuilder <IAudioProviderFactory>(); _sources = ImmutableList.CreateBuilder <ITrackSource>(); _transcoders = ImmutableList .CreateBuilder <IAudioTranscoderFactory>(); _socketCount = 20; _decoders.AddRange( services.GetServices <IAudioDecoderFactory>()); _providers.AddRange( services.GetServices <IAudioProviderFactory>()); _sources.AddRange( services.GetServices <ITrackSource>()); _transcoders.AddRange( services.GetServices <IAudioTranscoderFactory>()); }
public void RegisterAction <T>() where T : IIndexable, new() { _actions.Add(new T()); var actionType = typeof(T); ImmutableList <ActionMapping> actionTypesOne = actionType.GetInterfaces() .Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IAction <>)) .Select(x => new ActionMapping(actionType, x.GenericTypeArguments[0])) .ToImmutableList(); _actionMappings = _actionMappings.AddRange(actionTypesOne); ImmutableList <ConvertMapping> convertTypes = actionType.GetInterfaces() .Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IConvert <,>)) .Select(x => new ConvertMapping(actionType, x.GenericTypeArguments[0], x.GenericTypeArguments[1])) .ToImmutableList(); _convertMappings = _convertMappings.AddRange(convertTypes); _updateCounter += 1; }
static CachedOperatorTypeLoader() { var allOperatorTypeLoader = new OperatorTypeLoader(); var types = allOperatorTypeLoader.LoadOperatorTypes(); var operators = types.Select(allOperatorTypeLoader.LoadOperator); _cachedTypes = _cachedTypes.AddRange(types); _cachedOperators = _cachedOperators.AddRange(operators); AppDomain.CurrentDomain.AssemblyLoad += (sender, args) => { try { var operatorTypeLoader = new OperatorTypeLoader(); var newAssemblyTypes = operatorTypeLoader.LoadOperatorTypes(args.LoadedAssembly); var newOperators = newAssemblyTypes.Select(operatorTypeLoader.LoadOperator); _cachedTypes = _cachedTypes.AddRange(newAssemblyTypes); _cachedOperators = _cachedOperators.AddRange(newOperators); } catch (Exception e) { NLog.LogManager.GetCurrentClassLogger().Error(e, "Loading operators from a new assembly failed"); } }; }