}//UpdateQuotes().
//
//
// *************************************************
// **** MarketInstrumentChanged() ****
// *************************************************
public void MarketInstrumentChanged(Book marketBook, InstrumentChangeArgs eventArgs)
{
if (m_IsQuoteSideUpdateRequired[0] || m_IsQuoteSideUpdateRequired[1])
{
UpdateQuotes();
}
}// MarketInstrumentChanged()
}// MarketInstrumentInitialized()
//
//
#endregion //Startup methods
#region Public Run-Time methods
//
//
//
// ****************************************************************
// **** MarketInstrumentChanged() ****
// ****************************************************************
/// <summary>
/// The main pricing update.
/// </summary>
/// <param name="marketBook"></param>
/// <param name="eventArgs"></param>
/// <param name="isForceUpdate"></param>
public void MarketInstrumentChanged(Book marketBook, InstrumentChangeArgs eventArgs, bool isForceUpdate)
{
foreach (PricingEngine pricingEngine in this.PricingEngines)
{
pricingEngine.MarketInstrumentChanged(marketBook, eventArgs);
}
m_QuoteEngine.MarketInstrumentChanged(marketBook, eventArgs);
}// MarketInstrumentChanged()
}// MarketInstrumentInitialized()
//
//
//
// ****************************************************************
// **** MarketInstrumentChanged() ****
// ****************************************************************
/// <summary>
/// The main pricing update.
/// </summary>
/// <param name="marketBook"></param>
/// <param name="isForceUpdate"></param>
public void MarketInstrumentChanged(Book marketBook, InstrumentChangeArgs eventArgs, bool isForceUpdate)
{
m_PricingEngine.MarketInstrumentChanged(marketBook, eventArgs);
/*
* if (m_OrderEngine != null && m_OrderEngine.m_OrderInstrument != null)
* {
* m_OrderEngine.UpdateOrders(isForceUpdate); // TODO: we need not check this if pricing model is not changed recently.
* if (isForceUpdate)
* m_OrderEngine.SynchronizeRunningState();
* }
*/
}// MarketChange()
}// MarketInstrumentInitialized()
//
//
//
// ****************************************************
// **** Market Instrument Changed() ****
// ****************************************************
/// <summary>
/// Called whenever the market changes.
/// Notes:
/// 1) If you extend the PricingEngine class, and override this
/// method, call this base version first!
/// </summary>
/// <param name="marketBook"></param>
/// <returns></returns>
public virtual bool MarketInstrumentChanged(Book marketBook, InstrumentChangeArgs eventArgs)
{
this.m_IsUpdateRequired = false; // reset my flag.
ImpliedMarket.SetMarket(marketBook, m_Legs); // update my market depth
// Inform subscribers of market change.
bool isMarketSubscriberChanged = false;
foreach (IMarketSubscriber iMarketSubscriber in m_MarketSubscribers)
{
isMarketSubscriberChanged = iMarketSubscriber.MarketInstrumentChanged(marketBook, eventArgs) || isMarketSubscriberChanged;
}
return(isMarketSubscriberChanged);
}//end MarketChange().
//
//
/// <summary>
/// Called by the executionListener thread to process an event on the queue.
/// </summary>
private void ProcessEvent()
{
if (m_isDisposing)
{
return;
}
EventArgs e;
while (m_InQueue.TryDequeue(out e)) //remove from threadsafe queue
{
m_WorkQueue.Enqueue(e); // place on my current work stack
}
//
// Process all events now
//
while (m_WorkQueue.Count > 0)
{
e = m_WorkQueue.Dequeue();
if (e is EngineEventArgs)
{
EngineEventArgs engEvent = (EngineEventArgs)e;
if (engEvent.EngineID >= 0)
{
m_ExecContainer.EngineList[engEvent.EngineID].ProcessEvent(engEvent);
if (engEvent.Status == EngineEventArgs.EventStatus.Confirm || engEvent.Status == EngineEventArgs.EventStatus.Failed)
{
m_EngineHub.OnEngineChanged(engEvent);
}
}
if (engEvent.MsgType == EngineEventArgs.EventType.SyntheticOrder)
{
m_ExecContainer.IOrderEngine.ProcessEvent(e);
}
}
else if (e is InstrumentChangeArgs)
{ // this is a market update.
// 1. Fill Orders ( we should do this first)
// 2. Update Internal Markets
InstrumentChangeArgs instrChangeArgs = (InstrumentChangeArgs)e;
m_MarketInstrumentIdChangedList.Clear(); // load ids for instruments we need to check.
foreach (KeyValuePair <int, InstrumentChange> pair in instrChangeArgs.ChangedInstruments)
{
if (pair.Value.MarketDepthChanged[QTMath.BidSide].Contains(0) || pair.Value.MarketDepthChanged[QTMath.AskSide].Contains(0))
{
m_MarketInstrumentIdChangedList.Add(pair.Value.InstrumentID);
}
}
if (m_MarketInstrumentIdChangedList.Count > 0)
{
SimulateFills(m_MarketInstrumentIdChangedList);
SimulateMarketUpdates(m_MarketInstrumentIdChangedList);
}
}
else if (e is FoundServiceEventArg)
{
FoundServiceEventArg foundServiceEvent = (FoundServiceEventArg)e;
if (foundServiceEvent.FoundInstruments != null && foundServiceEvent.FoundInstruments.Count != 0)
{
foreach (InstrumentName instrName in foundServiceEvent.FoundInstruments)
{
if (!m_ExecContainer.m_Markets.ContainsKey(instrName))
{
UV.Lib.BookHubs.Market newMarket = UV.Lib.BookHubs.Market.Create(instrName);
m_ExecContainer.m_Markets.Add(instrName, newMarket);
}
InstrumentDetails instrDetails;
if (m_Market.TryGetInstrumentDetails(instrName, out instrDetails))
{
ProcessInstrumentsFound(instrDetails);
}
}
}
}
}
}
//
protected override InstrumentChangeArgs ProcessBookEventsForABook(int bookID, List <EventArgs> eArgList)
{
BookHubs.Book aBook = m_Book[bookID];
List <InstrumentName> newMarketsFound = null;
int ithInstr = 0;
while (ithInstr < m_InstrumentsToUpdate.Count)
{
int instrId = m_InstrumentsToUpdate[ithInstr];
BookHubs.Market mkt;
if (!aBook.Instruments.TryGetValue(instrId, out mkt))
{
ithInstr++;
continue;
}
DB.Queries.MarketDataItem mktItems = m_MarketItems[instrId][m_MarketItemPtrs[instrId]];
bool isChanged = false;
double p;
int q;
bool firstUpdate = mkt.DeepestLevelKnown < 0;
for (int side = 0; side < 2; ++side)
{
p = mktItems.Price[side];
q = mktItems.Qty[side];
if (p != mkt.Price[side][0] || q != mkt.Qty[side][0])
{
mkt.SetMarket(side, 0, p, q, mkt.Volume[side], 0);
isChanged = true;
}
}
if (!isChanged)
{
m_InstrumentsToUpdate.RemoveAt(ithInstr);
if (firstUpdate)
{
mkt.DeepestLevelKnown = -1; // keep this -1 to remember we are not updated.
}
}
else
{
if (firstUpdate)
{
if (newMarketsFound == null)
{
newMarketsFound = new List <InstrumentName>();
}
newMarketsFound.Add(mkt.Name);
}
ithInstr++;
}
}
// New instruments found?
if (newMarketsFound != null)
{
OnMarketInstrumentFound(newMarketsFound);
}
InstrumentChangeArgs instrChangedArgs = new InstrumentChangeArgs(); // create change args for all instruments
foreach (int instrId in m_InstrumentsToUpdate)
{
instrChangedArgs.AppendChangedInstrument(instrId, m_ChangedDepths); // assume all changes are top of book
}
return(instrChangedArgs);
}// ProcessBookEventsForABook()
