public void Copy(BaseStatus Other)
{
LastClose = Other.LastClose;
OpenPrice = Other.OpenPrice;
HighPrice = Other.HighPrice;
LowPrice = Other.LowPrice;
NowPrice = Other.NowPrice;
Status = Other.Status;
}
public static TradingStatus GetTradingStatus(int statusCode)
{
TradingStatus status = TradingStatus.Unknown;
if (Enum.IsDefined(typeof(TradingStatus), statusCode))
{
status = (TradingStatus)Enum.ToObject(typeof(TradingStatus), statusCode);
}
return(status);
}
//
//
//
// **** PriceSubscription_Updated() ****
//
private void PriceSubscription_Updated(object sender, FieldsUpdatedEventArgs eventArgs)
{
if (m_isDisposing)
{
return;
}
bool isSnapShot = (eventArgs.UpdateType == UpdateType.Snapshot);
if (eventArgs.Error == null)
{
// Analyze
FieldId[] changedFieldIds = eventArgs.Fields.GetChangedFieldIds();
if (changedFieldIds.Length > 0)
{
InstrumentKey key = eventArgs.Fields.Instrument.Key;
MistyProd.InstrumentName instrKey;
if (m_KeyToInstruments.TryGetValue(key, out instrKey))
{
m_NewEvents.Clear();
// Bid side
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.BestBidPrice) || changedFieldIds.Contains <FieldId>(FieldId.BestBidQuantity))
{
Price p = (Price)eventArgs.Fields.GetField(FieldId.BestBidPrice).Value;
Quantity q = (Quantity)eventArgs.Fields.GetField(FieldId.BestBidQuantity).Value;
if (p.IsValid && q.IsValid)
{
int qty = q.ToInt();
if (qty > 0)
{
Misty.Lib.BookHubs.MarketUpdateEventArgs e = new Misty.Lib.BookHubs.MarketUpdateEventArgs();
//e.Instrument = instrument;
e.Name = instrKey;
e.Price = p.ToDouble();
e.Qty = q.ToInt();
e.Side = QTMath.BidSide;
m_NewEvents.Add(e);
}
}
}
// Ask side
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.BestAskPrice) || changedFieldIds.Contains <FieldId>(FieldId.BestAskQuantity))
{
Price p = (Price)eventArgs.Fields.GetField(FieldId.BestAskPrice).Value;
Quantity q = (Quantity)eventArgs.Fields.GetField(FieldId.BestAskQuantity).Value;
if (p.IsValid && q.IsValid)
{
int qty = q.ToInt();
if (qty > 0)
{
Misty.Lib.BookHubs.MarketUpdateEventArgs e = new Misty.Lib.BookHubs.MarketUpdateEventArgs();
//e.Instrument = instrument;
e.Name = instrKey;
e.Price = p.ToDouble();
e.Qty = q.ToInt();
e.Side = QTMath.AskSide;
m_NewEvents.Add(e);
}
}
}
// Last
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.LastTradedPrice) || changedFieldIds.Contains <FieldId>(FieldId.LastTradedQuantity))
{
Price p = (Price)eventArgs.Fields.GetField(FieldId.LastTradedPrice).Value;
Quantity q = (Quantity)eventArgs.Fields.GetField(FieldId.LastTradedQuantity).Value;
if (p == 0)
{
//int nn = 0;
}
if (p.IsValid && q.IsValid)
{
int qty = q.ToInt();
if (qty > 0)
{
Misty.Lib.BookHubs.MarketUpdateEventArgs e = new Misty.Lib.BookHubs.MarketUpdateEventArgs();
//e.Instrument = instrument;
e.Name = instrKey;
e.Price = p.ToDouble();
e.Qty = q.ToInt();
e.Side = QTMath.LastSide;
m_NewEvents.Add(e);
}
}
}
// Total Volume
/*
* if (isSnapShot || changedFieldIds.Contains<FieldId>(FieldId.TotalTradedQuantity))
* {
* object f = eventArgs.Fields.GetField(FieldId.TotalTradedQuantity).Value;
* Quantity q = (Quantity)eventArgs.Fields.GetField(FieldId.LastTradedQuantity).Value;
* if (q.IsValid)
* {
* Misty.Lib.BookHubs.MarketUpdateEventArgs e = new Misty.Lib.BookHubs.MarketUpdateEventArgs();
* e.Instrument = instrument;
* e.Qty = q.ToInt();
* //e.Side = QTMath.LastSide;
* //m_NewEvents.Add(e);
* }
* }
* if (isSnapShot || changedFieldIds.Contains<FieldId>(FieldId.HighPrice))
* {
* object f = eventArgs.Fields.GetField(FieldId.HighPrice).Value;
* }
* if (isSnapShot || changedFieldIds.Contains<FieldId>(FieldId.LowPrice))
* {
* object f = eventArgs.Fields.GetField(FieldId.LowPrice).Value;
* }
*/
/*
* if (changedFieldIds.Contains<FieldId>(FieldId.OpenPrice))
* {
* object f = eventArgs.Fields.GetField(FieldId.OpenPrice).Value;
* }
* if (isSnapShot || changedFieldIds.Contains<FieldId>(FieldId.SettlementPrice))
* {
* object f = eventArgs.Fields.GetField(FieldId.SettlementPrice).Value;
* }
*/
// Series Status
if (changedFieldIds.Contains <FieldId>(FieldId.SeriesStatus))
{
TradingStatus status = (TradingStatus)eventArgs.Fields.GetField(FieldId.SeriesStatus).Value;
Log.NewEntry(LogLevel.Minor, "PriceListener: SeriesStatus change {0} is {1}.", instrKey, status.ToString());
Misty.Lib.BookHubs.MarketStatusEventArgs e = new Misty.Lib.BookHubs.MarketStatusEventArgs();
//e.Instrument = instrument;
e.InstrumentName = instrKey;
if (status == TradingStatus.Trading)
{
e.Status = Misty.Lib.BookHubs.MarketStatus.Trading;
}
else if (status == TradingStatus.Closed || status == TradingStatus.ClosingAuction || status == TradingStatus.Expired ||
status == TradingStatus.NotTradable || status == TradingStatus.PostTrading)
{
e.Status = Misty.Lib.BookHubs.MarketStatus.NotTrading;
}
else
{
e.Status = Misty.Lib.BookHubs.MarketStatus.Special;
}
m_NewEvents.Add(e);
}
// Session rollover
if (changedFieldIds.Contains <FieldId>(FieldId.SessionRollover))
{
TradingStatus status = (TradingStatus)eventArgs.Fields.GetField(FieldId.SeriesStatus).Value;
Log.NewEntry(LogLevel.Minor, "PriceListener: SessionRollover change {0} is {1}.", instrKey, status.ToString());
Misty.Lib.BookHubs.MarketStatusEventArgs e = new Misty.Lib.BookHubs.MarketStatusEventArgs();
//e.Instrument = instrument;
e.InstrumentName = instrKey;
if (status == TradingStatus.Trading)
{
e.Status = Misty.Lib.BookHubs.MarketStatus.Trading;
}
else if (status == TradingStatus.Closed || status == TradingStatus.ClosingAuction || status == TradingStatus.Expired ||
status == TradingStatus.NotTradable || status == TradingStatus.PostTrading)
{
e.Status = Misty.Lib.BookHubs.MarketStatus.NotTrading;
}
else
{
e.Status = Misty.Lib.BookHubs.MarketStatus.Special;
}
m_NewEvents.Add(e);
}
//
// Fire events
//
ProcessPriceChangeEvents(ref m_NewEvents);
}// if instrument not found for ttKey.
else
{
Log.NewEntry(LogLevel.Warning, "{0}: Failed to find instrument for TTKey {1}.", this.Name, key);
}
}
}
else
{
Log.NewEntry(LogLevel.Warning, "{0}: Error in price subscription {1}.", this.Name, eventArgs.Error.Message);
}
}//PriceSubscription()
//
//
//******************************************************************
//**** PriceSubscription_Updated() ****
//******************************************************************
/// <summary>
/// NOTE : Currently this system only worries about "direct" or non implied qty's
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
private void PriceSubscription_Updated(object sender, FieldsUpdatedEventArgs eventArgs)
{
if (m_isDisposing)
{
return;
}
bool isSnapShot = (eventArgs.UpdateType == UpdateType.Snapshot);
bool isFireMarketBaseEvent = false;
if (eventArgs.Error == null)
{
UVProd.InstrumentName instrumentName;
InstrumentKey key = eventArgs.Fields.Instrument.Key;
if (m_KeyToInstruments.TryGetValue(key, out instrumentName))
{
// Analyze by finding the first depth at which a field has changed
m_NewEvents.Clear();
MarketBase newEvent = m_Market.m_MarketBaseFactory.Get(); // Get an event arg.
newEvent.Clear(); // make sure our event is clean.
newEvent.Name = instrumentName;
int maxDepth = Math.Min(MarketBase.MaxDepth, eventArgs.Fields.GetLargestCurrentDepthLevel());
newEvent.DeepestLevelKnown = maxDepth;
FieldId[] changedFieldIds;
for (int changedDepth = 0; changedDepth < maxDepth; changedDepth++)
{
changedFieldIds = eventArgs.Fields.GetChangedFieldIds(changedDepth);
if (changedFieldIds.Length > 0)
{
// *****************************************************
// **** MarketBase updates ****
// *****************************************************
//
// Bid side
//
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.DirectBidPrice) || changedFieldIds.Contains <FieldId>(FieldId.DirectBidQuantity))
{
isFireMarketBaseEvent = true;
newEvent.ChangedIndices[MarketBase.BidSide].Add(changedDepth);
Price p = (Price)eventArgs.Fields.GetDirectBidPriceField(changedDepth).Value;
Quantity q = (Quantity)eventArgs.Fields.GetDirectBidQuantityField(changedDepth).Value;
if (p.IsValid && p.IsTradable)
{
newEvent.Price[MarketBase.BidSide][changedDepth] = p.ToDouble();
newEvent.Qty[MarketBase.BidSide][changedDepth] = q.ToInt();;
}
}
//
// Ask side
//
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.DirectAskPrice) || changedFieldIds.Contains <FieldId>(FieldId.DirectAskQuantity))
{
isFireMarketBaseEvent = true;
newEvent.ChangedIndices[MarketBase.AskSide].Add(changedDepth);
Price p = (Price)eventArgs.Fields.GetDirectAskPriceField(changedDepth).Value;
Quantity q = (Quantity)eventArgs.Fields.GetDirectAskQuantityField(changedDepth).Value;
if (p.IsValid && p.IsTradable)
{
newEvent.Price[MarketBase.AskSide][changedDepth] = p.ToDouble();
newEvent.Qty[MarketBase.AskSide][changedDepth] = q.ToInt();;
}
}
//
// Last
//
// Here, we do not distinguish between buy/sell side volume. Hence only total volume is
// counted here. The total volume is indexed as "MarketBase.LastSide".
// If we ever decide we want more information than this we can use a TimeAndSalesSubscription which will report side
// to help sorting out the side of the market
//
if (isSnapShot || changedFieldIds.Contains <FieldId>(FieldId.LastTradedPrice) || changedFieldIds.Contains <FieldId>(FieldId.LastTradedQuantity))
{
isFireMarketBaseEvent = true; // i think we need to fire this for strategies that care about volume
Price p = (Price)eventArgs.Fields.GetField(FieldId.LastTradedPrice).Value;
Quantity q = (Quantity)eventArgs.Fields.GetField(FieldId.LastTradedQuantity).Value;
Quantity totalVolume = (Quantity)eventArgs.Fields.GetField(FieldId.TotalTradedQuantity).Value;
if (p.IsValid && q.IsValid)
{
newEvent.Price[MarketBase.LastSide][0] = p.ToDouble();
newEvent.Qty[MarketBase.LastSide][0] = q.ToInt();;
newEvent.ChangedIndices[MarketBase.LastSide].Add(0); // last price is always top of book
newEvent.Volume[MarketBase.LastSide] = totalVolume.ToInt(); // Only identify total volume.
m_InstrKeyToVolume[key][QTMath.LastSide] = totalVolume.ToInt(); // save total volume in array.
}
}
if (changedDepth == 0)
{
// *****************************************************
// **** Series Status updates ****
// *****************************************************
if (changedFieldIds.Contains <FieldId>(FieldId.SeriesStatus))
{
TradingStatus status = (TradingStatus)eventArgs.Fields.GetField(FieldId.SeriesStatus).Value;
Log.NewEntry(LogLevel.Minor, "PriceListener: SeriesStatus change {0} is {1}.", instrumentName, status.ToString());
UV.Lib.BookHubs.MarketStatusEventArgs e = new UV.Lib.BookHubs.MarketStatusEventArgs();
//e.Instrument = instrument;
e.InstrumentName = instrumentName;
if (status == TradingStatus.Trading)
{
e.Status = UV.Lib.BookHubs.MarketStatus.Trading;
}
else if (status == TradingStatus.Closed || status == TradingStatus.ClosingAuction || status == TradingStatus.Expired ||
status == TradingStatus.NotTradable || status == TradingStatus.PostTrading)
{ // we have entered into a "non trading" state, so we need to reset our volume counts
e.Status = UV.Lib.BookHubs.MarketStatus.NotTrading;
foreach (int[] volumeArray in m_InstrKeyToVolume.Values)
{ // for every volume array
for (int i = 0; i < volumeArray.Length; i++)
{ // set volume back to zero for all sides except last, since we use session volume as reported by TT
if (i == QTMath.LastSide)
{
continue;
}
volumeArray[i] = 0;
}
}
}
else
{
e.Status = UV.Lib.BookHubs.MarketStatus.Special;
}
m_NewEvents.Add(e);
}
// *****************************************************
// **** Session Rollover ****
// *****************************************************
if (changedFieldIds.Contains <FieldId>(FieldId.SessionRollover))
{
TradingStatus status = (TradingStatus)eventArgs.Fields.GetField(FieldId.SeriesStatus).Value;
Log.NewEntry(LogLevel.Minor, "PriceListener: SessionRollover change {0} is {1}.", instrumentName, status.ToString());
UV.Lib.BookHubs.MarketStatusEventArgs e = new UV.Lib.BookHubs.MarketStatusEventArgs();
//e.Instrument = instrument;
e.InstrumentName = instrumentName;
if (status == TradingStatus.Trading)
{
e.Status = UV.Lib.BookHubs.MarketStatus.Trading;
}
else if (status == TradingStatus.Closed || status == TradingStatus.ClosingAuction || status == TradingStatus.Expired ||
status == TradingStatus.NotTradable || status == TradingStatus.PostTrading)
{
e.Status = UV.Lib.BookHubs.MarketStatus.NotTrading;
}
else
{
e.Status = UV.Lib.BookHubs.MarketStatus.Special;
}
m_NewEvents.Add(e);
}
}
} // end changed fields lenght
} // end changedepth loop
// *****************************************************
// **** Fire Events Now ****
// *****************************************************
if (isFireMarketBaseEvent)
{
m_NewEvents.Add(newEvent);
}
else
{
m_Market.m_MarketBaseFactory.Recycle(newEvent);
}
ProcessPriceChangeEvents(ref m_NewEvents);
} // end if instrument key not found
else
{
Log.NewEntry(LogLevel.Warning, "{0}: Failed to find instrument for TTKey {1}.", this.Name, key);
}
}
else
{
Log.NewEntry(LogLevel.Warning, "{0}: Error in price subscription {1}.", this.Name, eventArgs.Error.Message);
}
}//PriceSubscription()
