private void AppendFilter(StringBuilder querySb, string clause, ISqlFilter filter, bool parametric, IReadOnlyList <ModifyQueryPartCallback> modificators) { if (filter != null) { var sql = parametric ? filter.ParametricSql : filter.RawSql; querySb.Append(SEPARATOR).Append(clause) .Append(SEPARATOR_WITH_OFFSET) .Append(modificators.Aggregate(sql, (result, callback) => callback(result))); } else if (modificators.Count > 0) { querySb.Append(modificators.Aggregate(string.Empty, (result, callback) => callback(result))); } }
private Dictionary <string, string> GetResultAsDictionary(IReadOnlyList <IResultSetValue> row) { Dictionary <string, string> result = new Dictionary <string, string>(); row.Aggregate(result, (a, b) => { a.Add(b.ColumnInfo.Name, b.ToString()); return(a); }); return(result); }
public Type CreateGenericType(IStaticScope parent, IOrType <NameKey, ImplicitKey> key, IReadOnlyList <TypeAndConverter> placeholders, IConvertTo <Type, IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType> > converter) { var res = new Type( this, $"generic-{key}-{placeholders.Aggregate("", (x, y) => x + "-" + y)}", Possibly.Is(key), converter, Possibly.IsNot <Guid>(), Possibly.IsNot <IInterfaceType>()); IsChildOf(parent, res); HasType(parent, key.SwitchReturns <IKey>(x => x, x => x), res); var i = 0; foreach (var placeholder in placeholders) { var placeholderType = new TypeProblem2.GenericTypeParameter(this, $"generic-parameter-{placeholder.key}", i++, Prototypist.Toolbox.OrType.Make <MethodType, Type, Method, InferredType>(res)); //var placeholderType = new Type( // this, // $"generic-parameter-{placeholder.key}", // Possibly.Is(placeholder.key), // placeholder.converter, // Possibly.IsNot<Guid>(), // Possibly.IsNot<IInterfaceType>()); HasGenericType(Prototypist.Toolbox.OrType.Make <MethodType, Type, Method>(res), placeholder.key, placeholderType); } return(res); }
public SimpleReadOnlySequenceSegment(IReadOnlyList <ReadOnlyMemory <T> > segments) { var runningIndex = segments.Aggregate((long)0, (v, s) => v + s.Length); SimpleReadOnlySequenceSegment <T>?nextSegment = null; for (int i = segments.Count - 1; i > 0; i--) { var segment = segments[i]; runningIndex -= segment.Length; nextSegment = new SimpleReadOnlySequenceSegment <T>(segment, runningIndex, nextSegment); } if (segments.Count > 0) { var firstSegment = segments[0]; runningIndex -= firstSegment.Length; Memory = firstSegment; } Debug.Assert(runningIndex == 0); RunningIndex = runningIndex; Next = nextSegment; _lastSegment = nextSegment?.LastSegment; }
public void TestMethod2() { const int keyCount = 13; for (var numKeyPairs = 4; numKeyPairs < 30; numKeyPairs += 2) { for (var numSwitchables = 10; numSwitchables < 100; numSwitchables += 10) { var rando = Rando.Fast(numSwitchables + 377); IReadOnlyList <IKeyPair> sorterStage = KeyPairRepository.RandomKeyPairs(13, numKeyPairs, rando.NextInt()).ToList(); for (var rep = 0; rep < 10; rep++) { var reducedSorterStage = sorterStage.ToReducedSorterStage( rando.Spawn().ToSwitchableGroup <uint>(Guid.NewGuid(), keyCount, numSwitchables) ); //if (reducedSorterStage.KeyPairs.Count > 6) //{ // System.Diagnostics.Debug.WriteLine(sorterStage.Aggregate("\n", (o, n) => o + " [" + n.LowKey + "," + n.HiKey + "]")); // System.Diagnostics.Debug.WriteLine(reducedSorterStage.KeyPairs.Aggregate(String.Empty, (o,n)=> o + " [" + n.LowKey + "," + n.HiKey + "]" )); //} System.Diagnostics.Debug.WriteLine(String.Format("{0}\t{1}\t{2}\t{3}\t{4}", numKeyPairs, numSwitchables, reducedSorterStage.KeyPairs.Count, sorterStage.Aggregate("", (o, n) => o + " [" + n.LowKey + "," + n.HiKey + "]"), reducedSorterStage.KeyPairs.Aggregate(String.Empty, (o, n) => o + " [" + n.LowKey + "," + n.HiKey + "]") )); } } } }
private static int CalculateHashCode(IReadOnlyList <string> values) { unchecked { return(values.Aggregate(1, (current, t) => current ^ (t.GetHashCode() * 397))); } }
private void BuildRow(IReadOnlyList <int> columnWidths, IReadOnlyList <string> rowValues) { var row = string.Empty; if (rowValues.Count > 0) { for (var i = 0; i < columnWidths.Count; i++) { row += settings.FieldDelimiter + rowValues[i].PadRight(columnWidths[i]) + string.Empty.PadRight(settings.Padding, ' '); if (i == rowValues.Count - 1) { row += settings.FieldDelimiter; } } } else { row = columnWidths.Aggregate(row, (current, t) => current + char.ToString(settings.RowDelimiter).PadRight(t + settings.Padding * 2, settings.RowDelimiter) + char.ToString(settings.RowDelimiter)); } table.AppendLine(row); }
private async Task ListIssuesResume(IDialogContext context, IAwaitable <string> repo) { _lastRepo = await repo; string token = await ValidateLoggedInAsync(context); if (!string.IsNullOrEmpty(token)) { IReadOnlyList <Issue> issues = await GitHubCommands.GetIssueList(token, _lastRepo, _lastDate); string msg; if (issues == null) { msg = "That repo doesn't exist or you don't have access to it. Try another one?"; } else if (!issues.Any()) { msg = $"There are no issues assigned to you in the **{_lastRepo}** repo."; } else { msg = issues.Aggregate($"These issues from the **{_lastRepo}** repo are assigned to you:", (current, issue) => current + Environment.NewLine + $"* [{issue.Number}]({issue.HtmlUrl}): {issue.Title}"); } await context.PostAsync(msg); } _lastDate = null; context.Wait(MessageReceived); }
public async Task <EnvironmentCost> GetCost(RenderingEnvironment env, QueryTimePeriod period) { var client = await _clientAccessor.GetClient(); var usageRequest = CreateUsageRequest(env, period); IReadOnlyList <Cost> costs = await Task.WhenAll(env.ExtractResourceGroupNames().Select( async rgName => { var result = await client.GetUsageForResourceGroup(env.SubscriptionId, rgName, usageRequest); if (result.Properties == null) { return(null); } else { return(new Cost(usageRequest.TimePeriod, result)); } })); costs = costs.Where(x => x != null).ToList(); if (!costs.Any()) { return(new EnvironmentCost(env.Name, null)); } return(new EnvironmentCost(env.Name, costs.Aggregate(Cost.Aggregate))); }
private IEnumerable <KeyValuePair <BattleProcess.ShipHpStatus, TriState> > CalcMvpStatus(IReadOnlyList <BattleProcess.ShipHpStatus> EndShips) { if (EndShips == null) { yield break; } var mvpRange = EndShips.Aggregate(new FuzzyInt(), (range, ship) => FuzzyInt.UpperRange(range, ship.DeliveredDamage)); var fuzzy = EndShips.Select(x => x.DeliveredDamage).Where(x => x.LowerBound != x.UpperBound); if (fuzzy.Count() != 0) { mvpRange.LowerBound = Math.Max(mvpRange.LowerBound, fuzzy.Max(x => x.UpperBound) / fuzzy.Count()); } var inRangeState = EndShips.Count(x => (x.DeliveredDamage >= mvpRange) != TriState.No) == 1 ? TriState.Yes : TriState.DK; if (mvpRange.UpperBound == mvpRange.LowerBound) { inRangeState = TriState.Yes; } foreach (var ship in EndShips) { yield return(new KeyValuePair <BattleProcess.ShipHpStatus, TriState>(ship, (ship.DeliveredDamage >= mvpRange) != TriState.No ? inRangeState : TriState.No)); if (mvpRange.UpperBound == mvpRange.LowerBound && ship.DeliveredDamage.LowerBound == mvpRange.LowerBound) { inRangeState = TriState.No; } } }
public static IScpWorkflowBuilder Update ( IScpWorkflowBuilder builder, IReadOnlyList <int> seeds, bool mergeWithPrev ) { return(new ScpWorkflowBuilderImpl( guid: builder.Guid.Add(seeds), inputEntities: InputEntityOptions(builder, mergeWithPrev), entity: seeds.Aggregate ( builder.Entity, (current, seed) => { var newWorkflow = Entity.Make( guid: builder.Guid.Add(seed), val: current.Value.Step(seed) ); return newWorkflow; } ), seeds: mergeWithPrev?builder.Seeds.Concat(seeds).ToList() : seeds.ToList() )); }
public async Task ListRepos(IDialogContext context, LuisResult result) { string token = await ValidateLoggedInAsync(context); if (!string.IsNullOrEmpty(token)) { EntityRecommendation eScope; result.TryFindEntity("ScopeType::Scope", out eScope); IReadOnlyList <Repository> repos = await GitHubCommands.GetRepoList(token, eScope?.Entity); string msg; if (!repos.Any()) { msg = "You don't own any repos on GitHub."; } else { msg = repos.Aggregate($"You own the following {eScope?.Entity} repos: ", (current, repo) => current + Environment.NewLine + $"* [{repo.Name}]({repo.HtmlUrl})"); } await context.PostAsync(msg); } context.Wait(MessageReceived); }
public void Flatten_Aggregated_List_Combined_With_Selector_Argument() { var result = _generator.SelectMany(i => _list.Aggregate((s, s1) => s + s1) + i); Assert.AreEqual('F', result.Generate()); Assert.AreEqual('o', result.Generate()); Assert.AreEqual('o', result.Generate()); Assert.AreEqual('B', result.Generate()); Assert.AreEqual('a', result.Generate()); Assert.AreEqual('r', result.Generate()); Assert.AreEqual('0', result.Generate()); Assert.AreEqual('F', result.Generate()); Assert.AreEqual('o', result.Generate()); Assert.AreEqual('o', result.Generate()); Assert.AreEqual('B', result.Generate()); Assert.AreEqual('a', result.Generate()); Assert.AreEqual('r', result.Generate()); Assert.AreEqual('1', result.Generate()); Assert.AreEqual('F', result.Generate()); Assert.AreEqual('o', result.Generate()); Assert.AreEqual('o', result.Generate()); Assert.AreEqual('B', result.Generate()); Assert.AreEqual('a', result.Generate()); Assert.AreEqual('r', result.Generate()); Assert.AreEqual('2', result.Generate()); }
public void Register(Identifier name, IReadOnlyList <IBlockProperty> properties, IReadOnlyList <dynamic> defaultValues) { var blockId = _blockStates.Count; var block = new Block(blockId, name, properties, defaultValues); _blocks[name] = block; Logger.Debug("Registering block {0}: {1}", blockId, block); var stateCount = properties.Aggregate(1, (current, property) => current * property.ValueCount); for (var blockData = 0; blockData < stateCount; blockData++) { var propertyCount = properties.Count; var tmp = blockData; var props = new dynamic[propertyCount]; for (var j = propertyCount - 1; j >= 0; j--) { var property = properties[j]; var propertySize = property.ValueCount; var valueIndex = tmp % propertySize; tmp /= propertySize; var value = property.GetValue(valueIndex); props[j] = value; } var stateId = blockId + blockData; _blockStates[stateId] = new BlockState(stateId, block, props); Logger.Debug("Registering block state {0}: {1}", stateId, _blockStates[stateId]); } }
static public Result <string, IImmutableDictionary <IImmutableList <string>, IReadOnlyList <byte> > > LoadFromAssemblyManifestResourceStreamContents( IReadOnlyList <IReadOnlyList <string> > filePaths, string resourceNameCommonPrefix, Assembly assembly) { var seed = Result <string, IImmutableDictionary <IImmutableList <string>, IReadOnlyList <byte> > > .ok( ImmutableDictionary <IImmutableList <string>, IReadOnlyList <byte> > .Empty .WithComparers(EnumerableExtension.EqualityComparer <IImmutableList <string> >())); return (filePaths .Aggregate( seed: seed, func: (aggregate, filePath) => { if (aggregate.Ok == null) { return aggregate; } var resourceName = resourceNameCommonPrefix + string.Join(".", filePath); var fileContent = GetManifestResourceStreamContentAsListOfBytes(assembly, resourceName); if (fileContent == null) { return Result <string, IImmutableDictionary <IImmutableList <string>, IReadOnlyList <byte> > > .err("Failed to get content for resource: " + resourceName); } return aggregate.map(dict => dict.SetItem(filePath.ToImmutableList(), fileContent)); })); }
public override IReadOnlyList <Vector2> Apply(Func <double> random, INamedDataCollection metadata, IReadOnlyList <Vector2> footprint, IReadOnlyList <Vector2> basis, IReadOnlyList <Vector2> lot) { var center = footprint.Aggregate((a, b) => a + b) / footprint.Count; var radians = _angle.SelectFloatValue(random, metadata).ToRadians(); return(footprint.Select(a => Vector3.Transform((a - center).X_Y(0), Quaternion.CreateFromAxisAngle(Vector3.UnitY, radians)).XZ() + center).ToArray()); }
public override int GetHashCode() { if (_typeArgs != null) { return(_typeArgs.Aggregate(_typeName.GetHashCode(), (h, s) => h + 37 * ObjectComparer.Instance.GetHashCode(s))); } return(_typeName.GetHashCode()); }
private IOrderItem DecoratePromotions(IOrderItem orderItem, IReadOnlyList <PromotionInfo> promotions) { if (promotions == null || promotions.Count == 0) { return(orderItem); } return(promotions.Aggregate(orderItem, ToPromotionDecorator)); }
private static IEnumerable <string> Transpose(IReadOnlyList <string> array) { var messageLength = array.First().Length; for (var i = 0; i < messageLength; i++) { yield return(array.Aggregate("", (current, t) => current + t[i])); } }
/// <summary> /// Returns the hash code of the current <see cref="ArrayNode"/>. /// </summary> public override int GetHashCode() { unchecked { var nameHash = Name != null?Comparers.NodeName.GetHashCode(Name) : 0; return(nameHash * 397 ^ children.Aggregate(children.Count, (current, element) => current * 397 ^ (element?.GetHashCode() ?? 0))); } }
private static void PrintBasicStatistics(History history, IReadOnlyList <Message> textMessages, string[] words) { // First and last message var startDate = textMessages[0].SendDate; var endDate = textMessages.Last().SendDate; var basicStatsTable = new ConsoleTable("First message", startDate.ToString(CultureInfo.CurrentCulture)) .AddRow("Last Message", endDate); // History timespan var totalMonths = (endDate.Year - startDate.Year) * 12 + endDate.Month - startDate.Month; totalMonths += endDate.Day < startDate.Day ? -1 : 0; var years = totalMonths / 12; var months = totalMonths % 12; var days = endDate.Subtract(startDate.AddMonths(totalMonths)).Days; var timeSpan = $"{years} year(s) {months} month(s) {days} day(s)"; basicStatsTable.AddRow("Timespan", timeSpan); // Message statistics var emptyDayCount = history.MissingDates.Aggregate(0, (sum, date) => sum + (date.To - date.From).Days); var totalDayCount = (endDate - startDate).Days; var percentageString = ((double)emptyDayCount / totalDayCount * 100).ToString("N2") + "%"; var emptyDayText = $"{emptyDayCount} (out of {totalDayCount} days) ({percentageString})"; // Message types var messageTypeCounts = history.Messages.GroupBy(message => message.Type) .Select(typeGroup => (typeGroup.Key, typeGroup.Count())) .ToDictionary(countTuple => countTuple.Key, countTuple => countTuple.Item2); basicStatsTable.AddRow("Number of days without activity", emptyDayText) .AddRow("Number of text messages", messageTypeCounts[MessageTypes.Text].ToString("N0")) .AddRow("Number of removed messages", messageTypeCounts[MessageTypes.Removed].ToString("N0")) .AddRow("Number of status messages", messageTypeCounts[MessageTypes.Status].ToString("N0")) .AddRow("Number of files sent", messageTypeCounts[MessageTypes.File].ToString("N0")) .AddRow("Number of calls", messageTypeCounts[MessageTypes.Call].ToString("N0")); // Average number of messages basicStatsTable.AddRow("Average number of messages a day", ((double)textMessages.Count / totalDayCount).ToString("N2")); // Word and character statistics basicStatsTable.AddRow("Number of words", words.Length.ToString("N0")); var characterCount = textMessages.Aggregate(0, (current, message) => current + message.Value.Length); basicStatsTable.AddRow("Number of characters", characterCount.ToString("N0")); basicStatsTable.AddRow("Average message length", $"{(double) words.Length / textMessages.Count:N2} words") .AddRow("Average word length", $"{(double) characterCount / words.Length:N2} characters"); basicStatsTable.Write(Format.Alternative); }
private static string MultipleMatchingErrorMessage(string name, IReadOnlyList <string> candidates, string assemblyName) { return (string.Format( "Multiple matches for name '{0}' were found in the assembly '{2}'. \n\nFound resources: {1}", name, candidates.Aggregate("", (accu, s) => accu + "\n" + s), assemblyName)); }
/// <summary> /// Marks <see cref="Ship"/> as destroyed /// </summary> public void Destroy() { if (isDestroyed) { throw new InvalidOperationException($"Ship positioned on cells: {cells.Aggregate("", (p, n) => p + " " + n.ToString())} was already destroyed"); } isDestroyed = true; }
static string ToList(IReadOnlyList <object> items) { if (items == null) { return(string.Empty); } return(items.Aggregate(string.Empty, (s, o) => s + (s.Length == 0 ? "" : ", ") + ((CollectionViewGalleryTestItem)o).Caption)); }
private static string ResourceNotFoundErrorMessage(string name, IReadOnlyList <string> candidates, string assemblyName) { return (string.Format( "The resource with name '{0}' that matches the given namesspace could not be found in the assembly '{2}'. " + "Did you set the 'Build Action' property to 'Embedded Resource'? \n\nFound resources: {1}", name, candidates.Aggregate("", (accu, s) => accu + "\n" + s), assemblyName)); }
public LambdaExpression ConstructResult() { var composed = resolvers.Reverse().Aggregate( Identity(GetCurrentReturnType()), (current, prev) => new PreambleReplacement(current).Replace(prev) ); var finalResult = constructionVisitors.Aggregate(composed, (prev, next) => next.VisitAndConvert(prev, nameof(ConstructResult))); return(finalResult); }
// Getting SVG path element string from a traced path internal static StringBuilder AppendSegments(StringBuilder stringBuilder, IReadOnlyList <Segment> segments, ColorReference color) { // Path stringBuilder.Append($"<path {color.ToSvgString()}d=\"M {segments.First().Start.X} {segments.First().Start.Y} "); //http://stackoverflow.com/a/217814/294804 segments.Aggregate(stringBuilder, (sb, segment) => sb.Append(segment.ToPathString())).Append("Z\" />"); // Rendering control points return(segments.Where(s => s.Radius > 0).Aggregate(stringBuilder, (sb, segment) => sb.Append(segment.ToControlPointString()))); }
public override int GetHashCode() { unchecked { var hashCode = (int)TwoGramCount; hashCode = (hashCode * 397) ^ (int)N1PlusStarww; hashCode = (hashCode * 397) ^ NwwStarCount.GetHashCode(); hashCode = ThreeGramCounts?.Aggregate(hashCode, (current, threeGram) => (int)((((current * 397) ^ threeGram.Key) * 397) ^ threeGram.Value)) ?? hashCode; hashCode = MostLikelies?.Aggregate(hashCode, (current, count) => (current * 397) ^ count) ?? hashCode; return(hashCode); } }
public CompilationUnitSyntax Generate(CompilationUnitSyntax compilationUnitSyntax, ClassToGenerate classToGenerate) { var classDeclarationSyntax = _syntaxGeneratorFacade.GetClassSyntax(classToGenerate.ClassName); classDeclarationSyntax = _classDeclarationGenerators .Aggregate(classDeclarationSyntax, (current, classDeclarationGenerator) => classDeclarationGenerator.Generate(current, classToGenerate)); var @namespace = _syntaxGeneratorFacade.GetNamespace(_namespace); @namespace = @namespace.AddMembers(classDeclarationSyntax); return(compilationUnitSyntax.AddMembers(@namespace)); }
public IValue Serialize() { return(List.Empty .Add(NameWithHash.Serialize()) .Add(CharacterId.Serialize()) .Add(Level.Serialize()) .Add(HairIndex.Serialize()) .Add(LensIndex.Serialize()) .Add(EarIndex.Serialize()) .Add(TailIndex.Serialize()) .Add(Costumes.Aggregate(List.Empty, (current, costume) => current.Add(costume.Serialize()))) .Add(Equipments.Aggregate(List.Empty, (current, equipment) => current.Add(equipment.Serialize())))); }
public static ExprType GetType(ExprType base_type, IReadOnlyList<Int32> indices) => indices.Aggregate(base_type, GetType);