public HighPassSummingAggregator(
IEnumerable <Measurement> measurements)
{
_measurements = measurements;
_filter = new HighPassFilter();
_aggregator = new SummingStrategy();
}
public PointsAggregator(
IEnumerable <Measurement> measurements,
IMeasurementFilter filter,
IAggregationStrategy aggregator)
{
_measurements = measurements;
_filter = filter;
_aggregator = aggregator;
}
public PointsAggregator(
IEnumerable<Measurement> measurements,
IMeasurementFilter filter,
IAggregationStrategy aggregator)
{
_measurements = measurements;
_filter = filter;
_aggregator = aggregator;
}
public PointsAggregator( // why do we want to take in measurements here? why not just pass in measurements for Aggregate?>
IEnumerable <Measurement> measurements, // pass in everything "Has a relationship"
IMeasurementFilter filter,
IAggregationStrategy aggregator)
{
_measurements = measurements;
_filter = filter;
_aggregator = aggregator;
}
public MetricRoute(
BucketReference bucketReference,
int frequencyInSeconds,
IAggregationStrategy aggregationStrategy)
{
this.aggregationStrategy = aggregationStrategy;
Bucket = bucketReference;
FrequencyInSeconds = frequencyInSeconds;
Logger = NullLogger.Instance;
}
public AggregationProvider(
ITableWrapper table,
IAffectedComponentPathProvider <TAggregationEntity> aggregationPathProvider,
IAggregationStrategy <TAggregationEntity> strategy,
IComponentAffectingEntityFactory <TAggregationEntity> aggregationFactory,
ILogger <AggregationProvider <TChildEntity, TAggregationEntity> > logger)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
_aggregationPathProvider = aggregationPathProvider ?? throw new ArgumentNullException(nameof(aggregationPathProvider));
_strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
_aggregationFactory = aggregationFactory ?? throw new ArgumentNullException(nameof(aggregationFactory));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public void CantCreateAggregatorWithNullStrategy()
{
// Arrange
IAggregationStrategy <TestItem, object> strategy = null !;
var size = 5;
var delay = 1000;
// Act
var exception = Record.Exception(() => new Aggregator <TestItem, object>(size, delay, strategy, CancellationToken.None));
// Assert
exception.Should().NotBeNull().And.BeOfType <ArgumentNullException>();
}
/// <summary>
/// Creates aggregator
/// </summary>
/// <param name="initialSize">Approximate size of the number of keys.</param>
/// <param name="millisecondsDelay">Delay in milliseconds when gets aggregates data from items.</param>
/// <param name="strategy">Aggregation strategy <see cref="IAggregationStrategy"/>.</param>
/// <param name="ct">Cancellation token for async operations.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="strategy"/> is null.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="initialSize"/> or <paramref name="millisecondsDelay"/> is incorrect.</exception>
public Aggregator(int initialSize, int millisecondsDelay, IAggregationStrategy <Item, KeyType> strategy, CancellationToken ct = default)
{
if (initialSize <= 0)
{
throw new ArgumentException("initialSize should be more than zero.", nameof(initialSize));
}
if (millisecondsDelay <= 0)
{
throw new ArgumentException("delay can not be negative.", nameof(millisecondsDelay));
}
if (strategy is null)
{
throw new ArgumentNullException(nameof(strategy));
}
_items = new Dictionary <KeyType, LinkedList <Item> >(initialSize);
_scheduledWork = new Dictionary <KeyType, Task>(initialSize);
_ct = ct;
_delay = millisecondsDelay;
_channel = Channel.CreateUnbounded <IEnumerable <Item> >();
_strategy = strategy;
}
public ScoreCalculator(List <Die> dice, IAggregationStrategy aggregationStrategy)
{
_dice = dice;
_aggregationStrategy = aggregationStrategy;
}
public CategoryScoreCalculator(List <IDie> dice, IDiceFilter diceFilter, IAggregationStrategy aggregationStrategy) // dependency injection
{
_dice = dice;
_diceFilter = diceFilter;
_aggregationStrategy = aggregationStrategy;
}
