private static void MergeCells(ITableBuilder tableBuilder, RenderingTemplate template)
{
foreach (var mergedCells in template.MergedCells)
{
tableBuilder.MergeCells(mergedCells);
}
}
public static ITable <TDatabase, TTable> Table <TDatabase, TTable>(this ITableBuilder <TDatabase> @this,
Expression <Func <TDatabase, IEnumerable <TTable> > > table,
string name = null,
string schema = null)
{
var builder = new InternalTableBuilder <TDatabase, TTable>((@this as TableBuilder <TDatabase>).DatabaseBuilder)
{
Property = ExpressionHelpers.ParsePropertySelector(table ?? throw ModelBuilderError.ArgumentNull(nameof(table)).AsException()),
Schema = schema
};
builder.Name = name ?? builder.Property.Name;
{
var priorTable = builder.DatabaseBuilder.Tables.FirstOrDefault(t => t.Property.Name == builder.Property.Name);
if (priorTable != null)
{
throw ModelBuilderError.TableRepeatedSelector(database: typeof(TDatabase).Name, property: builder.Property.Name, otherTable: BuilderHelper.GetTableName(priorTable.Schema, priorTable.Name)).AsException();
}
}
if (builder.DatabaseBuilder.Tables.Any(t => t.Schema == builder.Schema && t.Name == builder.Name))
{
throw ModelBuilderError.TableRepeatedName(BuilderHelper.GetTableName(builder.Schema, builder.Name)).AsException();
}
return(builder);
}
protected override void BuildTableCore(
TableDescriptor tableDescriptor,
Action <ITableBuilder, IDataExtensionRetrieval> createTable,
ITableBuilder tableBuilder)
{
this.BuildTableCoreCalls.Add(Tuple.Create(tableDescriptor, createTable, tableBuilder));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
// Get data from the cooker
var events = tableData.QueryOutput <ProcessedEventData <PerfettoPackageListEvent> >(
new DataOutputPath(PerfettoPluginConstants.PackageListCookerPath, nameof(PerfettoPackageListCooker.PackageListEvents)));
var tableGenerator = tableBuilder.SetRowCount((int)events.Count);
var baseProjection = Projection.Index(events);
tableGenerator.AddColumn(PackageNameColumn, baseProjection.Compose(x => x.PackageName));
tableGenerator.AddColumn(UidColumn, baseProjection.Compose(x => x.Uid));
tableGenerator.AddColumn(DebuggableColumn, baseProjection.Compose(x => x.Debuggable));
tableGenerator.AddColumn(ProfileableFromShellColumn, baseProjection.Compose(x => x.ProfileableFromShell));
tableGenerator.AddColumn(VersionCodeColumn, baseProjection.Compose(x => x.VersionCode));
// Default
List <ColumnConfiguration> defaultColumns = new List <ColumnConfiguration>()
{
PackageNameColumn,
TableConfiguration.PivotColumn, // Columns before this get pivotted on
UidColumn,
VersionCodeColumn,
ProfileableFromShellColumn,
TableConfiguration.GraphColumn,
};
var packageListDefaultConfig = new TableConfiguration("Default")
{
Columns = defaultColumns,
ChartType = ChartType.Line
};
tableBuilder.AddTableConfiguration(packageListDefaultConfig)
.SetDefaultTableConfiguration(packageListDefaultConfig);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var messages = tableData.QueryOutput <IReadOnlyList <IDiagnosticMessage> >(
DataOutputPath.ForSource(LTTngConstants.SourceId, LTTngDmesgDataCooker.Identifier, nameof(LTTngDmesgDataCooker.DiagnosticMessages)));
if (messages.Count == 0)
{
return;
}
var config = new TableConfiguration("MessagesByTimestamp")
{
Columns = new[]
{
messageColumn,
TableConfiguration.PivotColumn,
TableConfiguration.GraphColumn,
timestampColumn
},
};
config.AddColumnRole(ColumnRole.StartTime, timestampColumn);
config.AddColumnRole(ColumnRole.EndTime, timestampColumn);
var table = tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(messages.Count);
table.AddColumn(messageColumn, Projection.CreateUsingFuncAdaptor((i) => messages[i].Message));
table.AddColumn(timestampColumn, Projection.CreateUsingFuncAdaptor((i) => messages[i].Timestamp));
}
public IEnumerable <TableRowDTO> GetTable(string competitioName, CompetitionTableType tableType)
{
var games = gamesService.GetFinishedCompetitionGames(competitioName);
ITableBuilder builder = TableBuilderFactory.CreateTableBuilder(tableType);
return(builder.Build(games));
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
Debug.Assert(!(tableBuilder is null) && !(tableData is null));
var quicState = tableData.QueryOutput <QuicState>(new DataOutputPath(QuicEventCooker.CookerPath, "State"));
if (quicState == null)
{
return;
}
var events = quicState.Events
.Where(x => x.EventId == QuicEventId.DatapathSend || x.EventId == QuicEventId.DatapathRecv).ToArray();
if (events.Length == 0)
{
return;
}
var table = tableBuilder.SetRowCount(events.Length);
var dataProjection = Projection.Index(events);
table.AddColumn(processIdColumnConfig, dataProjection.Compose(ProjectProcessId));
table.AddColumn(cpuColumnConfig, dataProjection.Compose(ProjectCPU));
table.AddColumn(typeColumnConfig, dataProjection.Compose(ProjectType));
table.AddColumn(timeColumnConfig, dataProjection.Compose(ProjectTime));
table.AddColumn(bytesColumnConfig, dataProjection.Compose(ProjectBytes));
tableConfig1.AddColumnRole(ColumnRole.StartTime, timeColumnConfig);
tableBuilder.AddTableConfiguration(tableConfig1);
tableBuilder.SetDefaultTableConfiguration(tableConfig1);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
// Get data from the cooker
var events = tableData.QueryOutput <ProcessedEventData <PerfettoGpuCountersEvent> >(
new DataOutputPath(PerfettoPluginConstants.GpuCountersEventCookerPath, nameof(PerfettoGpuCountersEventCooker.GpuCountersEvents)));
var tableGenerator = tableBuilder.SetRowCount((int)events.Count);
var baseProjection = Projection.Index(events);
tableGenerator.AddColumn(NameColumn, baseProjection.Compose(x => x.Name));
tableGenerator.AddColumn(ValueColumn, baseProjection.Compose(x => x.Value));
tableGenerator.AddColumn(StartTimestampColumn, baseProjection.Compose(x => x.StartTimestamp));
tableGenerator.AddColumn(DurationColumn, baseProjection.Compose(x => x.Duration));
var tableConfig = new TableConfiguration("GPU Counters")
{
Columns = new[]
{
NameColumn,
TableConfiguration.PivotColumn, // Columns before this get pivotted on
StartTimestampColumn,
DurationColumn,
TableConfiguration.GraphColumn, // Columns after this get graphed
ValueColumn
},
ChartType = ChartType.Line
};
tableConfig.AddColumnRole(ColumnRole.StartTime, StartTimestampColumn.Metadata.Guid);
tableConfig.AddColumnRole(ColumnRole.Duration, DurationColumn);
tableBuilder
.AddTableConfiguration(tableConfig)
.SetDefaultTableConfiguration(tableConfig);
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
if (!TypeCheckingHelper.IsEnumerable(model.GetType()))
{
throw new ArgumentException("model is not IEnumerable");
}
var enumerableToRender = ((IEnumerable)model).Cast <object>().ToArray();
for (var i = 0; i < enumerableToRender.Length; ++i)
{
var element = enumerableToRender[i];
var normalizedElement = NormalizeElement(element);
tableBuilder.PushState();
var renderer = rendererCollection.GetRenderer(normalizedElement.GetType());
renderer.Render(tableBuilder, normalizedElement, template);
tableBuilder.PopState();
if (i != enumerableToRender.Length - 1)
{
tableBuilder.MoveToNextLayer();
}
}
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
var lastRow = template.Content.Cells.LastOrDefault();
foreach (var row in template.Content.Cells)
{
foreach (var cell in row)
{
tableBuilder.PushState(new Style(cell));
if (TemplateDescriptionHelper.IsCorrectFormValueDescription(cell.StringValue))
{
RenderFormControl(tableBuilder, model, cell);
}
else
{
RenderCellularValue(tableBuilder, model, cell);
}
tableBuilder.PopState();
}
if (!row.Equals(lastRow))
{
tableBuilder.MoveToNextLayer();
}
}
MergeCells(tableBuilder, template);
ResizeColumns(tableBuilder, template);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
Debug.Assert(!(tableBuilder is null) && !(tableData is null));
var quicState = tableData.QueryOutput <QuicState>(new DataOutputPath(QuicEventCooker.CookerPath, "State"));
if (quicState == null)
{
return;
}
var events = quicState.Events
.Where(x => x.ID == QuicEventId.StreamCreated || x.ID == QuicEventId.StreamDestroyed).ToArray();
if (events.Length == 0)
{
return;
}
var table = tableBuilder.SetRowCount(events.Length);
var dataProjection = Projection.Index(events);
table.AddColumn(typeColumnConfig, dataProjection.Compose(ProjectType));
table.AddColumn(countColumnConfig, Projection.Constant <uint>(1));
table.AddColumn(timeColumnConfig, dataProjection.Compose(ProjectTime));
tableConfig1.AddColumnRole(ColumnRole.StartTime, timeColumnConfig);
tableBuilder.AddTableConfiguration(tableConfig1);
tableBuilder.SetDefaultTableConfiguration(tableConfig1);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
// Get data from the cooker
var events = tableData.QueryOutput <ProcessedEventData <PerfettoFrameEvent> >(
new DataOutputPath(PerfettoPluginConstants.FrameEventCookerPath, nameof(PerfettoFrameEventCooker.FrameEvents)));
var tableGenerator = tableBuilder.SetRowCount((int)events.Count);
var baseProjection = Projection.Index(events);
var startProjection = baseProjection.Compose(x => x.StartTimestamp);
var endProjection = baseProjection.Compose(x => x.EndTimestamp);
tableGenerator.AddColumn(ProcessNameColumn, baseProjection.Compose(x => x.ProcessName));
tableGenerator.AddColumn(ProcessIdColumn, baseProjection.Compose(x => x.Upid));
tableGenerator.AddColumn(FrameTypeColumn, baseProjection.Compose(x => x.FrameType));
tableGenerator.AddColumn(JankTypeColumn, baseProjection.Compose(x => x.JankType));
tableGenerator.AddColumn(OnTimeFinishColumn, baseProjection.Compose(x => x.OnTimeFinish));
tableGenerator.AddColumn(DurationColumn, baseProjection.Compose(x => x.Duration));
tableGenerator.AddColumn(DisplayTokenColumn, baseProjection.Compose(x => x.DisplayFrameToken));
tableGenerator.AddColumn(SurfaceTokenColumn, baseProjection.Compose(x => x.SurfaceFrameToken));
tableGenerator.AddColumn(PresentTypeColumn, baseProjection.Compose(x => x.PresentType));
tableGenerator.AddColumn(PredictionTypeColumn, baseProjection.Compose(x => x.PredictionType));
tableGenerator.AddColumn(GpuCompositionColumn, baseProjection.Compose(x => x.GpuComposition));
tableGenerator.AddColumn(JankTagColumn, baseProjection.Compose(x => x.JankTag));
tableGenerator.AddColumn(StartTimestampColumn, startProjection);
tableGenerator.AddColumn(EndTimestampColumn, endProjection);
var jankFramesConfig = new TableConfiguration("Expected/Actual Frames by Process")
{
Columns = new[]
{
ProcessNameColumn,
DisplayTokenColumn,
SurfaceTokenColumn,
FrameTypeColumn,
TableConfiguration.PivotColumn, // Columns before this get pivotted on
PresentTypeColumn,
OnTimeFinishColumn,
PredictionTypeColumn,
JankTypeColumn,
JankTagColumn,
GpuCompositionColumn,
ProcessIdColumn,
DurationColumn,
TableConfiguration.GraphColumn, // Columns after this get graphed
StartTimestampColumn,
EndTimestampColumn
},
};
jankFramesConfig.AddColumnRole(ColumnRole.StartTime, StartTimestampColumn.Metadata.Guid);
jankFramesConfig.AddColumnRole(ColumnRole.EndTime, EndTimestampColumn.Metadata.Guid);
jankFramesConfig.AddColumnRole(ColumnRole.Duration, DurationColumn.Metadata.Guid);
tableBuilder
.AddTableConfiguration(jankFramesConfig)
.SetDefaultTableConfiguration(jankFramesConfig);
}
public void CreateTable(ITableBuilder tableBuilder)
{
Guard.ArgumentNotNull(tableBuilder, nameof(tableBuilder));
foreach (string statement in tableBuilder.Build())
{
this.Connection.Execute(statement); //execute create table and other DML Statements!
}
}
public void Configure(ITableBuilder <Product> builder)
{
builder.SetSchema("dbo").SetName("Products");
builder.SetForeignKey(e => e.OwnerId, e => e.Owner)
.References(e => e.Id, e => e.Products)
.SetOnDelete(DeleteRule.None);
}
public TeamEvaluationProgressTableDecorator(ITableBuilder builder,
List <TeamEvaluation> evaluations,
Assignment assignment)
: base(builder)
{
Evaluations = evaluations;
Assignment = assignment;
}
private void RenderCellularValue(ITableBuilder tableBuilder, object model, ICell cell)
{
var childModel = ExtractChildModel(model, cell);
var childTemplateName = ExtractTemplateName(cell);
var renderer = rendererCollection.GetRenderer(childModel.GetType());
renderer.Render(tableBuilder, childModel, templateCollection.GetTemplate(childTemplateName));
}
protected HtmlDataTable(HtmlHelper helper, string tableId, ITableBuilder parent, string url = null)
{
this.tableId = tableId;
this._helper = helper;
this.searchEnabled = true;
this.parent = parent;
this.url = url;
}
private static void ResizeColumns(ITableBuilder tableBuilder, RenderingTemplate template)
{
foreach (var column in template.Columns)
{
tableBuilder.ExpandColumn(column.Index - template.Range.UpperLeft.ColumnIndex + 1,
column.Width);
}
}
public int GetHashCode(ITableBuilder builder)
{
if (builder == null)
{
return(0);
}
return(builder.GetHashCode());
}
public void Render([NotNull] ITableBuilder tableBuilder, [NotNull] string name, [NotNull] object model)
{
if (!(model is bool boolToRender))
{
throw new InvalidOperationException("model is not bool");
}
tableBuilder.RenderCheckBoxValue(name, boolToRender);
}
protected override void BuildTableCore(
TableDescriptor tableDescriptor,
ITableBuilder tableBuilder)
{
if (tableDescriptor.IsMetadataTable)
{
BuildMetadataTable(tableDescriptor, tableBuilder);
}
}
protected virtual void VisitTable(ICreateBuilder expression, ITableBuilder table, IEnumerable <IColumnBuilder> columns)
{
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.CREATE);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.TABLE);
this.Visit(table);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.OPEN_PARENTHESES);
this.Visit(columns);
this.Builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.CLOSE_PARENTHESES);
}
public void Render([NotNull] ITableBuilder tableBuilder, [NotNull] string name, [NotNull] object model)
{
if (!(model is string stringToRender))
{
throw new InvalidOperationException("model is not string");
}
tableBuilder.RenderDropDownValue(name, stringToRender);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
Debug.Assert(!(tableBuilder is null) && !(tableData is null));
var quicState = tableData.QueryOutput <QuicState>(new DataOutputPath(QuicEventCooker.CookerPath, "State"));
if (quicState == null)
{
return;
}
var connections = quicState.Connections;
if (connections.Count == 0)
{
return;
}
var connData =
connections.SelectMany(
x => x.GetFlowBlockedEvents()
.Where(x => x.Flags != QuicFlowBlockedFlags.None)
.Select(y => new Data(x, y)));
var streamData =
connections.SelectMany(
x => x.Streams.SelectMany(
y => y.GetFlowBlockedEvents()
.Where(z => z.Flags != QuicFlowBlockedFlags.None)
.Select(z => new Data(x, z, y))));
var data = connData.Concat(streamData).ToArray();
var table = tableBuilder.SetRowCount(data.Length);
var dataProjection = Projection.Index(data);
table.AddColumn(connectionColumnConfig, dataProjection.Compose(ProjectId));
table.AddColumn(streamColumnConfig, dataProjection.Compose(ProjectStreamId));
table.AddColumn(processIdColumnConfig, dataProjection.Compose(ProjectProcessId));
table.AddColumn(reasonColumnConfig, dataProjection.Compose(ProjectReason));
table.AddColumn(countColumnConfig, Projection.Constant <uint>(1));
table.AddColumn(weightColumnConfig, dataProjection.Compose(ProjectWeight));
table.AddColumn(percentWeightColumnConfig, dataProjection.Compose(ProjectPercentWeight));
table.AddColumn(timeColumnConfig, dataProjection.Compose(ProjectTime));
table.AddColumn(durationColumnConfig, dataProjection.Compose(ProjectDuration));
tableConfig1.AddColumnRole(ColumnRole.StartTime, timeColumnConfig);
tableConfig1.AddColumnRole(ColumnRole.Duration, durationColumnConfig);
tableConfig1.InitialSelectionQuery = "[Series Name]:=\"Connection\" OR [Series Name]:=\"Reason\"";
tableBuilder.AddTableConfiguration(tableConfig1);
tableConfig2.AddColumnRole(ColumnRole.StartTime, timeColumnConfig);
tableConfig2.AddColumnRole(ColumnRole.Duration, durationColumnConfig);
tableConfig2.InitialSelectionQuery = "[Series Name]:=\"Reason\"";
tableBuilder.AddTableConfiguration(tableConfig2);
tableBuilder.SetDefaultTableConfiguration(tableConfig1);
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
WaLinuxAgentLogParsedResult parsedResult = tableData.QueryOutput <WaLinuxAgentLogParsedResult>(
DataOutputPath.Create(SourceParserIds.WaLinuxAgentLog, WaLinuxAgentDataCooker.CookerId, "ParsedResult"));
var logEntries = parsedResult.LogEntries;
var baseProjection = Projection.Index(logEntries);
var fileNameProjection = baseProjection.Compose(x => x.FilePath);
var lineNumberProjection = baseProjection.Compose(x => x.LineNumber);
var eventTimeProjection = baseProjection.Compose(x => x.EventTimestamp);
var logLevelProjection = baseProjection.Compose(x => x.LogLevel);
var logProjection = baseProjection.Compose(x => x.Log);
//
// Table Configurations describe how your table should be presented to the user:
// the columns to show, what order to show them, which columns to aggregate, and which columns to graph.
// You may provide a number of columns in your table, but only want to show a subset of them by default so as not to overwhelm the user.
// The user can still open the table properties in UI to turn on or off columns.
// The table configuration class also exposes four (4) columns that UI explicitly recognizes: Pivot Column, Graph Column, Left Freeze Column, Right Freeze Column
// For more information about what these columns do, go to "Advanced Topics" -> "Table Configuration" in our Wiki. Link can be found in README.md
//
var config = new TableConfiguration("Default")
{
Columns = new[]
{
LogLevelColumn,
TableConfiguration.PivotColumn,
LineNumberColumn,
LogColumn,
EventTimestampDateTimeColumn,
TableConfiguration.GraphColumn,
EventTimestampColumn,
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, EventTimestampColumn);
//
//
// Use the table builder to build the table.
// Add and set table configuration if applicable.
// Then set the row count (we have one row per file) and then add the columns using AddColumn.
//
tableBuilder
.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(logEntries.Count)
.AddColumn(FileNameColumn, fileNameProjection)
.AddColumn(LineNumberColumn, lineNumberProjection)
.AddColumn(EventTimestampColumn, eventTimeProjection)
.AddColumn(LogLevelColumn, logLevelProjection)
.AddColumn(LogColumn, logProjection);
}
protected override void BuildTableCore(
TableDescriptor tableDescriptor,
Action <ITableBuilder, IDataExtensionRetrieval> createTable,
ITableBuilder tableBuilder)
{
if (tableDescriptor.IsMetadataTable)
{
BuildMetadataTable(tableDescriptor, tableBuilder);
}
}
public static void BuildTable(ITableBuilder tableBuilder, IDataExtensionRetrieval tableData)
{
var threads = tableData.QueryOutput <IReadOnlyList <IThread> >(
DataOutputPath.Create(LTTngThreadDataCooker.CookerPath + "/Threads"));
if (threads.Count == 0)
{
return;
}
var config = new TableConfiguration("ThreadsByProcessId")
{
Columns = new[]
{
processIdColumn,
threadIdColumn,
commandColumn,
TableConfiguration.PivotColumn,
threadExecTimeColumn,
threadReadyTimeColumn,
threadRunningTimeColumn,
threadSleepTimeColumn,
threadDiskSleepTimeColumn,
threadWaitingTimeColumn,
threadIdleTimeColumn,
TableConfiguration.GraphColumn,
threadStartTimeColumn,
threadExitTimeColumn
},
Layout = TableLayoutStyle.GraphAndTable,
};
config.AddColumnRole(ColumnRole.StartTime, threadStartTimeColumn);
config.AddColumnRole(ColumnRole.EndTime, threadExitTimeColumn);
var table = tableBuilder.AddTableConfiguration(config)
.SetDefaultTableConfiguration(config)
.SetRowCount(threads.Count);
table.AddColumn(threadIdColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ThreadId));
table.AddColumn(processIdColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ProcessId));
table.AddColumn(commandColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].Command));
table.AddColumn(threadExecTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExecTime));
table.AddColumn(threadReadyTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ReadyTime));
table.AddColumn(threadRunningTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExecTime + threads[i].ReadyTime));
table.AddColumn(threadSleepTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].SleepTime));
table.AddColumn(threadDiskSleepTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].DiskSleepTime));
table.AddColumn(threadWaitingTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].SleepTime + threads[i].DiskSleepTime));
table.AddColumn(threadStoppedTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].StoppedTime));
table.AddColumn(threadParkedTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ParkedTime));
table.AddColumn(threadIdleTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].IdleTime));
table.AddColumn(threadStartTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].StartTime));
table.AddColumn(threadExitTimeColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExitTime));
table.AddColumn(threadLifespanColumn, Projection.CreateUsingFuncAdaptor((i) => threads[i].ExitTime - threads[i].StartTime));
}
public ReportBuilder AddTable(ITableBuilder tableBuilder)
{
if (report.Tables == null)
{
report.Tables = new List <PdfTableModel>();
}
report.Tables.Add(tableBuilder.Build(HasAlternatingRowBackgroundColor, AlternatingRowBackgroundColor));
return(this);
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
if (!(model is string stringToRender))
{
throw new ArgumentException("model is not string");
}
tableBuilder.RenderAtomicValue(stringToRender);
tableBuilder.SetCurrentStyle();
tableBuilder.MoveToNextColumn();
}
private void BuildMetadataTable(
TableDescriptor tableDescriptor,
ITableBuilder tableBuilder)
{
if (tableDescriptor.Guid == TraceStatsTable.TableDescriptor.Guid)
{
TraceStatsTable.BuildMetadataTable(
tableBuilder,
this.SourceParser as LTTngSourceParser,
this.ApplicationEnvironment.Serializer);
}
}
public GameBuilder(IModuleFactory moduleFactory, ILogicBuilder logicBuilder, IDealerBuilder dealerBuilder, IDeckBuilder deckBuilder, ITableBuilder tableBuilder, IPlayerBuilder playerBuilder)
{
_moduleFactory = moduleFactory;
_logicBuilder = logicBuilder;
_dealerBuilder = dealerBuilder;
_deckBuilder = deckBuilder;
_tableBuilder = tableBuilder;
_playerBuilder = playerBuilder;
}
public IGameBuilder TableBuilderIs(ITableBuilder builder)
{
_tableBuilder = builder;
return this;
}
public MatchBuilder(IEnumerable<RawMatch> matches, IEnumerable<Team> teams, ITableBuilder tableBuilder)
{
_matches = matches ?? Enumerable.Empty<RawMatch>();
_teams = teams;
_tableBuilder = tableBuilder;
}
public DealerBuilder(IDeckBuilder deckBuilder, ITableBuilder tableBuilder)
{
_deck = deckBuilder.Build();
_table = tableBuilder.Build();
}
