/// <summary>
/// Name : doMod
/// Description : Modify an existing event in the market depth cache.
/// Find the cached market depth entry by the position in
/// new the market depth cache and replace the cached event
/// by the fields and data in the new event.
/// </summary>
/// <param name="pos">position to be modified</param>
/// <param name="entry">new book entry</param>
public void doMod(int pos, ref BookEntry entry)
{
lock (d_entries)
{
d_entries[pos] = entry;
}
}
/// <summary>
/// Name : doReplaceByBroker
/// Description : This table command is used for top of file feeds
/// where the action is to replace by the broker mnemonic.
/// The recipient needs to find the broker in their cache
/// and replace the quote with the one in the market depth event.
/// If that broker is not present, it should added to the cache.
/// If the price and size for a broker is set to 0,
/// the broker should be deleted from the cache.
/// </summary>
/// <param name="entry">new book entry</param>
public void doReplaceByBroker(ref BookEntry entry)
{
lock (d_entries)
{
if (entry.Price == 0 && entry.Size == 0)
{
doDeleteByBroker(entry.Broker);
return;
}
bool brokerFound = false;
for (int index = 0; index < d_entries.Count; ++index)
{
if (d_entries[index].Broker == entry.Broker)
{
// replace broker entry
d_entries[index] = entry;
brokerFound = true;
break;
}
}
if (!brokerFound)
{
// add broker entry
d_entries.Add(entry);
}
}
}
/// <summary>
/// Name : BookEntry copy constructor
/// Description : Copy constructor for ByLevelBookEntry
/// </summary>
/// <param name="copy">BookEntry to be copied</param>
public BookEntry(BookEntry copy)
{
Price = copy.Price;
Time = copy.Time;
NumberOrders = copy.NumberOrders;
Size = copy.Size;
IsValid = copy.IsValid;
}
/// <summary>
/// Name : doExec
/// Description : Trade Execution. Find the corresponding order in the cache
/// replace the entry with the new entry and delete orders with
/// greater priority
/// </summary>
/// <param name="pos">position to be modified</param>
/// <param name="entry">new book entry</param>
public void doExec(int pos, ref BookEntry entry)
{
lock (d_entries)
{
d_entries[pos] = entry;
if (pos != 0)
{
d_entries.RemoveRange(0, pos);
}
}
}
/// <summary>
/// Name : doReplace
/// Description : Replace previous price level or order at this position.
/// Add price level or order if you do not have it currently in
/// the cache. A 0 price and size will be sent when there is
/// no active price or order at this level.
/// </summary>
/// <param name="pos">position to be modified</param>
/// <param name="entry">new book entry</param>
public void doReplace(int pos, ref BookEntry entry)
{
lock (d_entries)
{
if (d_entries.Count <= pos)
{
// fill in entries
for (int i = d_entries.Count; i <= pos; ++i)
{
d_entries.Add(new BookEntry());
}
}
d_entries[pos] = entry;
}
}
/// <summary>
/// Name : doAdd
/// Description : Add an entry to the order book.
/// When you add this order in the market depth table,
/// you should shift all orders at the market depth position
/// in the event and market depth orders or levels inferior to
/// event passed to one position inferior.
/// For example, if a new order is added to position one of the
/// market depth table, then the previous order at position one is
/// shifted to position two. The order at position two is shifted to
/// position three and so on until you get to the market depth window size.
/// </summary>
/// <param name="pos">position to add the entry</param>
/// <param name="entry">entry to add</param>
public void doAdd(int pos, BookEntry entry)
{
lock (d_entries)
{
if (d_entries.Count < pos)
{
// gap detected
System.Console.WriteLine("Gap detected in cache for level " + (pos + 1) +
". Cache size is " + d_entries.Count + ".");
return;
}
d_entries.Insert(pos, entry);
if (WindowSize < d_entries.Count)
{
//remove entries > window size
d_entries.RemoveRange(WindowSize, d_entries.Count - WindowSize);
}
}
}
/// <summary>
/// Name : doReplaceClear
/// Description : The REPLACE_CLEAR table command is intended to remove an order or
/// more often a level in the market depth cache. The REPLACE_CLEAR
/// should be indexed by the MarketDepth.ByLevel/ByOrder.Bid/Ask.Position
/// field. The cache should NOT be shifted up after the level is
/// cleared. A clear means all orders at that position have been deleted
/// from the orderbook. It is possible that a order or level at a
/// superior or most superior position to be cleared prior to more
/// inferior levels. After the level is cleared in this case, it is
/// expected that subsequent market depth event(s) will be passed
/// to clear the orders or levels at positions inferior to the one just
/// cleared.
/// </summary>
/// <param name="pos">position to be modified</param>
public void doReplaceClear(int pos)
{
lock (d_entries)
{
if (d_entries.Count <= pos)
{
// fill in entries
for (int i = d_entries.Count; i <= pos; ++i)
{
d_entries.Add(new BookEntry());
}
}
else
{
BookEntry entry = new BookEntry();
d_entries[pos] = entry;
}
}
}
/// <summary>
/// Name : getEtnry
/// Description : Returns the entry at the specified position
/// </summary>
/// <param name="pos">position of the entry</param>
/// <returns>true is the cache is valid, false if the cache is invalid</returns>
public BookEntry getEntry(int pos)
{
BookEntry entry = null;
lock (d_entries)
{
if (pos >= d_entries.Count)
{
entry = null;
}
else
{
entry = d_entries[pos];
if (!entry.IsValid)
{
// invalid entry
entry = null;
}
}
}
return(entry);
}
