public void DoesPush_IfDateDoesMatch_MultipleTimeBars()
{
var stack = new EquityIntraDayHistoryStack(TimeSpan.Zero);
var date = DateTime.UtcNow;
var tb = this.GetTimeBar();
var tb2 = this.GetTimeBar();
var timeBarCollection = new EquityIntraDayTimeBarCollection(
new Market("1", "xlon", "London Stock Exchange", MarketTypes.STOCKEXCHANGE),
date,
new[] { tb, tb2 });
var timeBarCollection2 = new EquityIntraDayTimeBarCollection(
new Market("1", "xlon", "London Stock Exchange", MarketTypes.STOCKEXCHANGE),
date,
new[] { tb, tb2 });
stack.Add(timeBarCollection, date);
stack.Add(timeBarCollection2, date);
var stackContents = stack.ActiveMarketHistory();
Assert.AreEqual(2, stackContents.Count);
Assert.AreEqual(timeBarCollection2, stackContents.Pop());
Assert.AreEqual(timeBarCollection, stackContents.Pop());
}
public void ExecuteTradeStrategy(EquityIntraDayTimeBarCollection frame, IOrderStream <Order> tradeOrders)
{
if (tradeOrders == null)
{
this._logger.Log(LogLevel.Error, "Received a null trade orders in the markov trade strategy");
throw new ArgumentNullException(nameof(tradeOrders));
}
if (frame == null)
{
this._logger.LogInformation("A null frame was passed to the markov trade strategy");
return;
}
if (frame.Securities == null || frame.Securities.All(sec => sec == null))
{
this._logger.LogInformation(
"No securities were present on the exchange frame in the markov trade strategy");
return;
}
var tradableSecurities = frame.Securities.Where(sec => sec != null).ToList();
var numberOfTradeOrders = this._tradeVolumeStrategy.CalculateSecuritiesToTrade(tradableSecurities);
if (numberOfTradeOrders <= 0)
{
this._logger.LogInformation("Markov trading strategy decided not to trade on this frame");
return;
}
this.GenerateAndSubmitTrades(frame, tradeOrders, numberOfTradeOrders);
}
private void Tick(object sender, EventArgs e)
{
if (this._tickLocked)
{
// don't tick if we're getting overwhelmed
this._logger.LogInformation("Ticks tocking too fast for equity generator");
return;
}
lock (this._walkingLock)
{
this._tickLocked = true;
if (!this._walkInitiated)
{
this._heartBeat?.Stop();
this._tickLocked = false;
return;
}
var tockedSecurities = this._activeFrame.Securities.Select(this.TickSecurity).ToArray();
var tickTock = new EquityIntraDayTimeBarCollection(
this._activeFrame.Exchange,
DateTime.UtcNow,
tockedSecurities);
this._activeFrame = tickTock;
this._stream.Add(tickTock);
this._tickLocked = false;
}
}
public void ArchiveEmptyCollection_OneItemToArchive_OneToKeep_ReturnsOne()
{
var stack = new EquityIntraDayHistoryStack(TimeSpan.Zero);
var date = DateTime.UtcNow;
var firstBar = date - TimeSpan.FromDays(2);
var tb = this.GetTimeBar();
var tb2 = this.GetTimeBar();
var timeBarCollection = new EquityIntraDayTimeBarCollection(
new Market("1", "xlon", "London Stock Exchange", MarketTypes.STOCKEXCHANGE),
firstBar,
new[] { tb, tb2 });
var timeBarCollection2 = new EquityIntraDayTimeBarCollection(
new Market("1", "xlon", "London Stock Exchange", MarketTypes.STOCKEXCHANGE),
DateTime.UtcNow,
new[] { tb, tb2 });
stack.Add(timeBarCollection, firstBar);
stack.Add(timeBarCollection2, date);
var stackContents = stack.ActiveMarketHistory();
Assert.AreEqual(2, stackContents.Count);
stack.ArchiveExpiredActiveItems(date);
var stackContentsAfterExpire = stack.ActiveMarketHistory();
Assert.AreEqual(1, stackContentsAfterExpire.Count);
Assert.AreEqual(timeBarCollection2, stackContentsAfterExpire.Pop());
}
public void Add(EquityIntraDayTimeBarCollection value)
{
if (value == null)
{
this._logger.LogInformation("UniverseMarketCache was asked to add null. returning");
return;
}
this._logger.LogInformation(
$"UniverseMarketCache adding {value.Epoch} - {value.Exchange?.MarketIdentifierCode}");
if (this._latestExchangeFrameBook.ContainsKey(value.Exchange.MarketIdentifierCode))
{
this._latestExchangeFrameBook.Remove(value.Exchange.MarketIdentifierCode);
this._latestExchangeFrameBook.Add(value.Exchange.MarketIdentifierCode, value);
}
else
{
this._latestExchangeFrameBook.Add(value.Exchange.MarketIdentifierCode, value);
}
if (!this._marketHistory.ContainsKey(value.Exchange.MarketIdentifierCode))
{
var history = new EquityIntraDayHistoryStack(this._windowSize);
history.Add(value, value.Epoch);
this._marketHistory.TryAdd(value.Exchange.MarketIdentifierCode, history);
}
else
{
this._marketHistory.TryGetValue(value.Exchange.MarketIdentifierCode, out var history);
history?.Add(value, value.Epoch);
history?.ArchiveExpiredActiveItems(value.Epoch);
}
}
public void OnNext_PassesFrame_ToConsole()
{
var subscriber = new ExchangeFrameDisplaySubscriber(this._console);
var frame = new EquityIntraDayTimeBarCollection(null, DateTime.UtcNow, null);
subscriber.OnNext(frame);
A.CallTo(() => this._console.OutputMarketFrame(frame)).MustHaveHappenedOnceExactly();
}
public override void OnNext(EquityIntraDayTimeBarCollection value)
{
if (value == null)
{
return;
}
this.OrderStrategy.ExecuteTradeStrategy(value, this.TradeStream);
}
private Order GenerateTrade(EquityInstrumentIntraDayTimeBar tick, EquityIntraDayTimeBarCollection exchFrame)
{
if (tick == null)
{
return(null);
}
var direction = this.CalculateTradeDirection();
var orderType = this.CalculateTradeOrderType();
var limit = this.CalculateLimit(tick, direction, orderType);
var executedPrice = this.CalculateExecutedPrice(tick);
var volume = this.CalculateVolume(tick);
var orderStatus = this.CalculateOrderStatus();
var orderStatusLastChanged = tick.TimeStamp.AddMilliseconds(300);
var orderSubmittedOn = tick.TimeStamp;
var traderId = this.GenerateClientFactorString();
var dealerInstructions = "Process Asap";
var orderCurrency = tick?.SpreadTimeBar.Price.Currency.Code ?? string.Empty;
var cancelledDate = orderStatus == OrderStatus.Cancelled ? (DateTime?)orderSubmittedOn : null;
var filledDate = orderStatus == OrderStatus.Filled ? (DateTime?)orderSubmittedOn : null;
return(new Order(
tick.Security,
tick.Market,
null,
$"order-{Guid.NewGuid()}",
DateTime.UtcNow,
string.Empty,
string.Empty,
Guid.NewGuid().ToString(),
orderSubmittedOn,
orderSubmittedOn,
null,
cancelledDate,
filledDate,
orderStatusLastChanged,
OrderTypes.MARKET,
direction,
new Currency(orderCurrency),
new Currency(orderCurrency),
OrderCleanDirty.CLEAN,
null,
limit,
executedPrice,
volume,
volume,
traderId,
traderId,
"Clearing-Bank",
dealerInstructions,
new OrderBroker(string.Empty, string.Empty, "Mr Broker", DateTime.Now, true),
null,
null,
OptionEuropeanAmerican.NONE,
new DealerOrder[0]));
}
public void RunRule_DoesNotRaiseAlertInEschaton_WhenBidirectionalTradeAndDoesNotExceedsWindowThreshold_AndNoMarketData()
{
var parameters = new LayeringRuleEquitiesParameters("id", TimeSpan.FromMinutes(30), null, 0.1m, null, null, false, true);
_tradingHoursService = new MarketTradingHoursService(_tradingHoursRepository, new NullLogger <MarketTradingHoursService>());
var rule = new LayeringRule(parameters, _alertStream, _orderFilter, _logger, _equityFactory, _fixedIncomeFactory, _tradingHoursService, _ruleCtx, RuleRunMode.ValidationRun, _tradingLogger);
var tradeBuy = ((Order)null).Random();
var tradeSell = ((Order)null).Random();
tradeBuy.OrderDirection = OrderDirections.BUY;
tradeBuy.FilledDate = tradeBuy.PlacedDate.Value.AddMinutes(1);
tradeSell.OrderDirection = OrderDirections.SELL;
tradeSell.FilledDate = tradeSell.PlacedDate.Value.AddMinutes(1);
tradeBuy.OrderFilledVolume = 100;
tradeSell.OrderFilledVolume = 100;
var market = new Market("1", "XLON", "London Stock Exchange", MarketTypes.STOCKEXCHANGE);
var marketData = new EquityIntraDayTimeBarCollection(market, tradeBuy.PlacedDate.Value.AddSeconds(-55),
new List <EquityInstrumentIntraDayTimeBar>
{
new EquityInstrumentIntraDayTimeBar(
tradeBuy.Instrument,
new SpreadTimeBar(
tradeBuy.OrderAverageFillPrice.Value,
tradeSell.OrderAverageFillPrice.Value,
tradeSell.OrderAverageFillPrice.Value,
new Volume(2000)),
new DailySummaryTimeBar(
1000,
"USD",
new IntradayPrices(tradeBuy.OrderAverageFillPrice.Value, tradeBuy.OrderAverageFillPrice.Value,
tradeBuy.OrderAverageFillPrice.Value, tradeBuy.OrderAverageFillPrice.Value),
1000,
new Volume(2000),
tradeBuy.PlacedDate.Value.AddSeconds(-55)),
tradeBuy.PlacedDate.Value.AddSeconds(-55),
market)
});
var genesis = new UniverseEvent(UniverseStateEvent.Genesis, tradeBuy.PlacedDate.Value.AddMinutes(-1), new object());
var marketDataEvent = new UniverseEvent(UniverseStateEvent.EquityIntraDayTick, tradeBuy.PlacedDate.Value.AddSeconds(-55), marketData);
var buyEvent = new UniverseEvent(UniverseStateEvent.OrderPlaced, tradeBuy.PlacedDate.Value, tradeBuy);
var sellEvent = new UniverseEvent(UniverseStateEvent.OrderPlaced, tradeSell.PlacedDate.Value, tradeSell);
var eschaton = new UniverseEvent(UniverseStateEvent.Eschaton, tradeSell.PlacedDate.Value.AddMinutes(1), new object());
rule.OnNext(genesis);
rule.OnNext(buyEvent);
rule.OnNext(sellEvent);
rule.OnNext(marketDataEvent);
rule.OnNext(eschaton);
A.CallTo(() => _alertStream.Add(A <IUniverseAlertEvent> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => _ruleCtx.EndEvent()).MustHaveHappenedOnceExactly();
}
public void OnNext_CallsOnCompleted_ForBlackListTrueSubscribers_Markets()
{
var markets = new RuleFilter {
Ids = new[] { "abc", "ghi" }, Type = RuleFilterType.Exclude
};
var filter = new UniverseFilterService(
this._unsubscriber,
this._highMarketCapFilter,
this._filteredRule,
null,
null,
markets,
null,
null,
null,
null,
null,
null,
this._logger);
filter.Subscribe(this._observer);
var accOne = ((Order)null).Random();
accOne.Market = new Market("1", "abc", "abc", MarketTypes.STOCKEXCHANGE);
var eventOne = new UniverseEvent(UniverseStateEvent.Order, DateTime.UtcNow, accOne);
var accTwo = ((Order)null).Random();
accTwo.Market = new Market("1", "def", "def", MarketTypes.STOCKEXCHANGE);
var eventTwo = new UniverseEvent(UniverseStateEvent.Order, DateTime.UtcNow, accTwo);
var exchangeOne = new EquityIntraDayTimeBarCollection(
new Market("1", "ghi", "ghi", MarketTypes.STOCKEXCHANGE),
DateTime.UtcNow,
new EquityInstrumentIntraDayTimeBar[0]);
var eventThree = new UniverseEvent(UniverseStateEvent.EquityIntraDayTick, DateTime.UtcNow, exchangeOne);
var exchangeTwo = new EquityIntraDayTimeBarCollection(
new Market("1", "jkl", "jkl", MarketTypes.STOCKEXCHANGE),
DateTime.UtcNow,
new EquityInstrumentIntraDayTimeBar[0]);
var eventFour = new UniverseEvent(UniverseStateEvent.EquityIntraDayTick, DateTime.UtcNow, exchangeTwo);
filter.OnNext(eventOne);
filter.OnNext(eventTwo);
filter.OnNext(eventThree);
filter.OnNext(eventFour);
A.CallTo(() => this._observer.OnNext(eventOne)).MustNotHaveHappened();
A.CallTo(() => this._observer.OnNext(eventTwo)).MustHaveHappenedOnceExactly();
A.CallTo(() => this._observer.OnNext(eventThree)).MustNotHaveHappened();
A.CallTo(() => this._observer.OnNext(eventFour)).MustHaveHappenedOnceExactly();
}
public void ToString_PrintsOutExpected_ExchangeAndSecurities()
{
var market = new Market("1", "xlon", "london stock exchange", MarketTypes.DarkPool);
var date = DateTime.UtcNow;
var timeBars = new EquityInstrumentIntraDayTimeBar[0];
var coll = new EquityIntraDayTimeBarCollection(market, date, timeBars);
var result = coll.ToString();
Assert.AreEqual("Exchange (xlon.london stock exchange) Securities(0)", result);
}
private IReadOnlyCollection <int> SecuritiesToTrade(EquityIntraDayTimeBarCollection frame, int securitiesToTrade)
{
var upperLimit = frame.Securities.Count - 1;
var securitiesToTradeIds = new List <int>();
for (var count = 0; count < securitiesToTrade; count++)
{
securitiesToTradeIds.Add(DiscreteUniform.Sample(0, upperLimit));
}
return(securitiesToTradeIds);
}
public void Ctor_AssignsVariables_Correctly()
{
var market = new Market("1", "xlon", "london stock exchange", MarketTypes.DarkPool);
var date = DateTime.UtcNow;
var timeBars = new EquityInstrumentIntraDayTimeBar[0];
var coll = new EquityIntraDayTimeBarCollection(market, date, timeBars);
Assert.AreEqual(market, coll.Exchange);
Assert.AreEqual(date, coll.Epoch);
Assert.AreEqual(timeBars, coll.Securities);
}
public void DailyParameter_NoThresholdBreach_DoesNotRaiseAlert()
{
var windows = new TimeWindows("id", TimeSpan.FromHours(1));
A.CallTo(() => _equitiesParameters.HighVolumePercentageDaily).Returns(0.1m);
A.CallTo(() => _equitiesParameters.Windows).Returns(windows);
var highVolumeRule = BuildRule();
var trade = Trade();
var underlyingTrade = (Order)trade.UnderlyingEvent;
underlyingTrade.FilledDate = DateTime.UtcNow;
underlyingTrade.OrderFilledVolume = 10;
underlyingTrade.FilledDate = DateTime.UtcNow;
var market = new Market("1", "XLON", "London Stock Exchange", MarketTypes.STOCKEXCHANGE);
var marketData = new EquityIntraDayTimeBarCollection(market, underlyingTrade.PlacedDate.Value.AddSeconds(-55),
new List <EquityInstrumentIntraDayTimeBar>
{
new EquityInstrumentIntraDayTimeBar(
underlyingTrade.Instrument,
new SpreadTimeBar(
underlyingTrade.OrderAverageFillPrice.Value,
underlyingTrade.OrderAverageFillPrice.Value,
underlyingTrade.OrderAverageFillPrice.Value,
new Volume(2000)),
new DailySummaryTimeBar(
1000m,
"USD",
new IntradayPrices(
underlyingTrade.OrderAverageFillPrice.Value,
underlyingTrade.OrderAverageFillPrice.Value,
underlyingTrade.OrderAverageFillPrice.Value,
underlyingTrade.OrderAverageFillPrice.Value),
10000,
new Volume(10000),
underlyingTrade.PlacedDate.Value.AddSeconds(-55)),
underlyingTrade.PlacedDate.Value.AddSeconds(-55),
market)
});
var marketEvent =
new UniverseEvent(
UniverseStateEvent.EquityIntraDayTick,
DateTime.UtcNow.AddMinutes(-1),
marketData);
highVolumeRule.OnNext(marketEvent);
highVolumeRule.OnNext(trade);
highVolumeRule.OnNext(Eschaton());
A.CallTo(() => _alertStream.Add(A <IUniverseAlertEvent> .Ignored)).MustHaveHappenedOnceExactly();
}
public void Add(EquityIntraDayTimeBarCollection frame, DateTime currentTime)
{
if (frame == null)
{
return;
}
lock (this._lock)
{
if (currentTime.Subtract(frame.Epoch) <= this._activeTradeDuration)
{
this._activeStack.Push(frame);
}
}
}
public override void OnNext(EquityIntraDayTimeBarCollection value)
{
lock (this._lock)
{
if (!this._initiated)
{
this._heartbeat.OnBeat(this.TradeOnHeartbeat);
this._initiated = true;
}
if (value == null) return;
this._lastFrame = value;
}
}
public void DoesPush_SetAMarket_OnExchangeCall()
{
var stack = new EquityIntraDayHistoryStack(TimeSpan.Zero);
var date = DateTime.UtcNow;
var tb = this.GetTimeBar();
var venue = new Market("1", "xlon", "London Stock Exchange", MarketTypes.STOCKEXCHANGE);
var timeBarCollection = new EquityIntraDayTimeBarCollection(venue, DateTime.UtcNow, new[] { tb });
stack.Add(timeBarCollection, date);
var exch = stack.Exchange();
Assert.AreEqual(exch, venue);
}
public void DoesNotPush_IfDateDoesNotMatch()
{
var stack = new EquityIntraDayHistoryStack(TimeSpan.Zero);
var date = DateTime.UtcNow;
var tb = this.GetTimeBar();
var timeBarCollection = new EquityIntraDayTimeBarCollection(
new Market("1", "xlon", "London Stock Exchange", MarketTypes.STOCKEXCHANGE),
date,
new[] { tb });
stack.Add(timeBarCollection, date + TimeSpan.FromDays(1));
var stackContents = stack.ActiveMarketHistory();
Assert.IsEmpty(stackContents);
}
private void Tick(DateTime advanceTick, IEquityDataGeneratorStrategy strategy)
{
lock (this._walkingLock)
{
var tockedSecurities = this._activeFrame.Securities
.Select(sec => strategy.AdvanceFrame(sec, advanceTick, false)).ToArray();
var tickTock = new EquityIntraDayTimeBarCollection(
this._activeFrame.Exchange,
advanceTick,
tockedSecurities);
this._activeFrame = tickTock;
this._stream.Add(tickTock);
}
}
private void AdvanceFrames(ExchangeDto market, EquityIntraDayTimeBarCollection frame)
{
if (frame.Epoch.TimeOfDay > market.MarketCloseTime)
{
this._logger.Log(LogLevel.Error, "ended up advancing a frame whose start exceeded market close time");
return;
}
var timeSpanList = new List <TickStrategy>();
var advanceTick = frame.Epoch.TimeOfDay;
while (advanceTick <= market.MarketCloseTime)
{
timeSpanList.Add(new TickStrategy {
TickOffset = advanceTick, Strategy = this._dataStrategy
});
advanceTick = advanceTick.Add(this._tickSeparation);
}
timeSpanList = this.RemoveConflictingTicks(timeSpanList);
foreach (var subPlan in this._plan)
{
var strategy = new PlanEquityStrategy(subPlan, this._dataStrategy);
var initialTick = subPlan.EquityInstructions.IntervalCommencement;
while (initialTick <= subPlan.EquityInstructions.IntervalTermination)
{
timeSpanList.Add(new TickStrategy {
TickOffset = initialTick, Strategy = strategy
});
initialTick = initialTick.Add(subPlan.EquityInstructions.UpdateFrequency);
}
}
timeSpanList = timeSpanList.OrderBy(i => i.TickOffset).ToList();
foreach (var item in timeSpanList)
{
if (item?.Strategy == null)
{
continue;
}
this.Tick(frame.Epoch.Date.Add(item.TickOffset), item.Strategy);
}
}
public void Add(EquityIntraDayTimeBarCollection frame)
{
if (frame == null)
{
return;
}
if (this._observers == null)
{
return;
}
foreach (var obs in this._observers)
{
obs.Value?.OnNext(frame);
}
}
public void OutputMarketFrame(EquityIntraDayTimeBarCollection frame)
{
lock (this._lock)
{
if (frame == null)
{
WriteToLine(this._marketFrameOffset, "*****************************");
WriteToLine(this._marketFrameOffset + 1, "Market. Empty frame");
WriteToLine(this._marketFrameOffset + 2, "*****************************");
return;
}
WriteToLine(this._marketFrameOffset, "*****************************");
WriteToLine(this._marketFrameOffset + 1, $"Market Frame ({frame.Epoch}). {frame}");
WriteToLine(this._marketFrameOffset + 2, "*****************************");
}
}
private IUniverseEvent MapRowToIntradayMarketDataEvent(IntradayMarketDataParameters marketDataParam)
{
if (marketDataParam == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(marketDataParam.SecurityName) ||
!this._securitySelection.Securities.ContainsKey(marketDataParam.SecurityName))
{
this._scenarioContext.Pending();
return(null);
}
if (marketDataParam.Bid == null || marketDataParam.Ask == null || marketDataParam.Price == null)
{
this._scenarioContext.Pending();
return(null);
}
var security = this._securitySelection.Securities[marketDataParam.SecurityName];
var bid = this.MapToMoney(marketDataParam.Bid, marketDataParam.Currency);
var ask = this.MapToMoney(marketDataParam.Ask, marketDataParam.Currency);
var price = this.MapToMoney(marketDataParam.Price, marketDataParam.Currency);
var volume = new Volume(marketDataParam.Volume.GetValueOrDefault(0));
var intradayPrices = new SpreadTimeBar(bid.Value, ask.Value, price.Value, volume);
var marketData = new EquityInstrumentIntraDayTimeBar(
security.Instrument,
intradayPrices,
null,
marketDataParam.Epoch,
security.Market);
var timeBarCollection = new EquityIntraDayTimeBarCollection(
security.Market,
marketDataParam.Epoch,
new[] { marketData });
var universeEvent = new UniverseEvent(
UniverseStateEvent.EquityIntraDayTick,
marketDataParam.Epoch,
timeBarCollection);
return(universeEvent);
}
private void GenerateAndSubmitTrades(
EquityIntraDayTimeBarCollection frame,
IOrderStream <Order> tradeOrders,
int numberOfTradeOrders)
{
var securitiesToTradeIds = this.SecuritiesToTrade(frame, numberOfTradeOrders);
var securitiesToTrade = securitiesToTradeIds.Select(sec => frame.Securities.ElementAt(sec)).ToList();
var trades = securitiesToTrade.Select(sec => this.GenerateTrade(sec, frame)).Where(trade => trade != null)
.ToList();
foreach (var trade in trades)
{
tradeOrders.Add(trade);
}
this._logger.LogInformation($"Submitted {trades.Count} trade orders in frame");
}
public void OnNext(EquityIntraDayTimeBarCollection value)
{
if (value == null)
{
this._baseGenerator.OnNext(null);
return;
}
var filteredSecurities =
value.Securities?.Where(
sec => this._sedols.Contains(
sec?.Security.Identifiers.Sedol,
StringComparer.CurrentCultureIgnoreCase) == this._inclusive).ToList()
?? new List <EquityInstrumentIntraDayTimeBar>();
var filteredFrame = new EquityIntraDayTimeBarCollection(value.Exchange, value.Epoch, filteredSecurities);
this._baseGenerator.OnNext(filteredFrame);
}
public void OnNext(EquityIntraDayTimeBarCollection value)
{
var csvRecords = value?.Securities?.Select(this._securityMapper.Map).Where(w => w != null).ToList()
?? new List <FinancialInstrumentTimeBarCsv>();
if (!csvRecords.Any())
{
return;
}
var fileName = $"{value.Exchange.Id}-{value.Epoch.ToString("yyyyMMddHHmmssffff")}.csv";
var filePath = Path.Combine(this._path, fileName);
using (var writer = File.CreateText(filePath))
{
var csv = new CsvWriter(writer);
csv.Configuration.HasHeaderRecord = true;
csv.WriteRecords(csvRecords);
}
}
public void InitiateWalk(IStockExchangeStream stream)
{
this._logger.LogInformation("Walk initiated in equity generator");
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
lock (this._stateTransitionLock)
{
this._walkInitiated = true;
this._stream = stream;
this._activeFrame = this._exchangeTickInitialiser.InitialFrame();
this._stream.Add(this._activeFrame);
this._heartBeat.OnBeat(this.Tick);
this._heartBeat.Start();
}
}
public override void OnNext(EquityIntraDayTimeBarCollection value)
{
if (value == null)
{
return;
}
if (this._plan == null)
{
return;
}
lock (this._lock)
{
if (!this._initialCluster && this._plan.EquityInstructions.CommencementInUtc <= value.Epoch)
{
this.WashTradeInSecurityWithClustering(this._plan.Sedol, value, 20);
this._initialCluster = true;
return;
}
if (!this._secondaryCluster && this._plan.EquityInstructions.TerminationInUtc <= value.Epoch)
{
this.WashTradeInSecurityWithClustering(this._plan.Sedol, value, 30);
this._secondaryCluster = true;
return;
}
if (!this._thirdCluster && this._thirdGroupActivation <= value.Epoch)
{
this.WashTradeInSecurityWithClustering(this._plan.Sedol, value, 20);
this._thirdCluster = true;
}
}
}
private DataGenerationPlan PlanInDateRange(EquityIntraDayTimeBarCollection value)
{
if (!this._plan?.Any() ?? true)
{
return(null);
}
if (value == null)
{
return(null);
}
foreach (var plan in this._plan)
{
if (plan.EquityInstructions.CommencementInUtc <= value.Epoch &&
plan.EquityInstructions.TerminationInUtc >= value.Epoch)
{
return(plan);
}
}
return(null);
}
public override void OnNext(EquityIntraDayTimeBarCollection value)
{
if (value == null)
{
return;
}
if (!this._plan?.Any() ?? true)
{
return;
}
this._intraDayHistoryStack.Add(value, value.Epoch);
var plan = this.PlanInDateRange(value);
if (plan == null)
{
return;
}
lock (this._lock)
{
this._intraDayHistoryStack.ArchiveExpiredActiveItems(value.Epoch);
var activeItems = this._intraDayHistoryStack.ActiveMarketHistory();
if (plan.EquityInstructions.TerminationInUtc == value.Epoch)
{
this.CreateLayeringTradesForWindowBreachInSedol(plan.Sedol, activeItems, value, false);
this.CreateLayeringTradesForWindowBreachInSedol(plan.Sedol, activeItems, value, true);
}
else
{
this.CreateLayeringTradesForWindowBreachInSedol(plan.Sedol, activeItems, value, false);
}
}
}
