public Iterable <CreateOrChangeOrder> GetActiveOrders(SymbolInfo symbol)
{
ActiveList <CreateOrChangeOrder> activeOrders = new ActiveList <CreateOrChangeOrder>();
activeOrders.AddLast(increaseOrders);
activeOrders.AddLast(decreaseOrders);
activeOrders.AddLast(marketOrders);
return(activeOrders);
}
public InventoryGroupMaster(SymbolInfo symbol)
{
this.symbol = symbol;
var inventory = new InventoryGroupDefault(symbol, 1);
active.AddLast(inventory);
inventories.AddLast(inventory);
ApplySettings();
maximumSpread = 100 * symbol.MinimumTick;
}
private void Adjust(ActiveList <PhysicalOrder> list, PhysicalOrder order)
{
AssureNode(order);
var node = (LinkedListNode <PhysicalOrder>)order.Reference;
if (node.List == null)
{
list.AddLast(node);
}
else if (!node.List.Equals(list))
{
node.List.Remove(node);
list.AddLast(node);
}
}
private void Adjust(ActiveList <CreateOrChangeOrder> list, CreateOrChangeOrder order)
{
AssureNode(order);
var addedOne = false;
var node = (ActiveListNode <CreateOrChangeOrder>)order.Reference;
if (node.List == null)
{
list.AddLast(node);
}
else if (!node.List.Equals(list))
{
node.List.Remove(node);
list.AddLast(node);
}
}
public void EnumerableTest()
{
ActiveList <int> list = new ActiveList <int>();
for (int i = 0; i < 10; i++)
{
list.AddLast(i);
}
Iterable <int> active = list;
var next = active.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
if (node.Value == 5)
{
list.AddAfter(list.First, 22);
}
}
StringBuilder sb = new StringBuilder();
next = active.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
sb.Append(node.Value);
sb.Append(", ");
}
Assert.AreEqual("0, 22, 1, 2, 3, 4, 5, 6, 7, 8, 9, ", sb.ToString());
}
public void AddOrder(LogicalOrder order)
{
if (OrderManager != null)
{
OrderManager.AddOrder(order);
}
allOrders.AddLast(order);
ordersHash.Add(order.Id, order);
}
public void OrderModified(LogicalOrder order)
{
if (order.IsActive)
{
// Any change to an active order even if only
// a price change means the list change.
IsActiveOrdersChanged = true;
if (!activeOrders.Contains(order))
{
var newNode = nodePool.Create(order);
bool found = false;
var next = activeOrders.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
LogicalOrder other = node.Value;
if (order.CompareTo(other) < 0)
{
activeOrders.AddBefore(node, newNode);
found = true;
break;
}
}
if (!found)
{
activeOrders.AddLast(newNode);
}
}
}
else
{
var node = activeOrders.Find(order);
if (node != null)
{
activeOrders.Remove(node);
nodePool.Free(node);
// Since this order became inactive, it
// means the active list changed.
IsActiveOrdersChanged = true;
}
}
if (order.IsNextBar)
{
if (!nextBarOrders.Contains(order))
{
nextBarOrders.Add(order);
}
}
else
{
if (nextBarOrders.Contains(order))
{
nextBarOrders.Remove(order);
}
}
ActiveOrdersChanged(order);
}
public bool AddCancelOrder(PhysicalOrder order)
{
var result = !HasCancelOrder(order);
if (!result)
{
cancelOrderQueue.AddLast(order);
}
return(result);
}
public bool AddCreateOrder(CreateOrChangeOrder order)
{
var result = !HasCreateOrder(order);
if (!result)
{
createOrderQueue.AddLast(order);
}
return(result);
}
public void SetLogicalOrders(Iterable <LogicalOrder> inputLogicals)
{
if (trace)
{
int count = originalLogicals == null ? 0 : originalLogicals.Count;
log.Trace("SetLogicalOrders() order count = " + count);
}
var orderCache = Factory.Engine.LogicalOrderCache(symbol);
orderCache.SetActiveOrders(inputLogicals);
lock ( bufferedLogicalsLocker) {
bufferedLogicals.Clear();
bufferedLogicals.AddLast(orderCache.ActiveOrders);
}
}
public LogicalOrder CreateOrder(StrategyInterface strategy, TradeDirection tradeDirection, OrderType orderType, double price, int position, int strategyPosition)
{
LogicalOrder order = Factory.Engine.LogicalOrder(symbol, strategy);
order.StrategyId = 1;
order.StrategyPosition = strategyPosition;
order.TradeDirection = tradeDirection;
order.Type = orderType;
order.Price = price;
order.Position = position * lotSize;
order.Status = OrderStatus.Active;
orders.AddLast(order);
strategy.Position.Change(strategyPosition, 100.00, TimeStamp.UtcNow);
return(order);
}
public Iterable <PhysicalOrder> GetActiveOrders(SymbolInfo symbol)
{
var result = new ActiveList <PhysicalOrder>();
lock ( openOrdersLocker) {
foreach (var kvp in openOrders)
{
var order = kvp.Value;
if (order.Symbol == symbol)
{
result.AddLast(order);
}
}
}
return(result);
}
public void TestRemoveWhileIterate()
{
ActiveList <int> list = new ActiveList <int>();
for (int i = 0; i < 10; i++)
{
list.AddLast(i);
}
var next = list.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
list.Remove(node.Value);
}
Assert.AreEqual(0, list.Count);
}
private void SortAdjust(ActiveList <CreateOrChangeOrder> list, CreateOrChangeOrder order, Func <CreateOrChangeOrder, CreateOrChangeOrder, double> compare)
{
AssureNode(order);
var orderNode = (ActiveListNode <CreateOrChangeOrder>)order.Reference;
if (orderNode.List == null || !orderNode.List.Equals(list))
{
if (orderNode.List != null)
{
orderNode.List.Remove(orderNode);
}
bool found = false;
var next = list.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
var other = node.Value;
if (object.ReferenceEquals(order, other))
{
found = true;
break;
}
else
{
var result = compare(order, other);
if (result < 0)
{
list.AddBefore(node, orderNode);
found = true;
break;
}
}
}
if (!found)
{
list.AddLast(orderNode);
}
}
}
public void TestAddLast()
{
list.AddLast(3);
Assert.AreEqual(1, list.Count);
list.AddLast(2);
Assert.AreEqual(2, list.Count);
list.AddLast(5);
Assert.AreEqual(3, list.Count);
list.AddLast(4);
Assert.AreEqual(4, list.Count);
list.AddLast(1);
Assert.AreEqual(5, list.Count);
var node = list.First;
Assert.AreEqual(3, node.Value);
node = node.Next;
Assert.AreEqual(2, node.Value);
node = node.Next;
Assert.AreEqual(5, node.Value);
node = node.Next;
Assert.AreEqual(4, node.Value);
node = node.Next;
Assert.AreEqual(1, node.Value);
}
private void PerformCompareInternal()
{
if (debug)
{
log.Debug("PerformCompare for " + symbol + " with " +
actualPosition + " actual " +
desiredPosition + " desired and " +
originalLogicals.Count + " logical, " +
originalPhysicals.Count + " physical.");
}
originalPhysicals.Clear();
originalPhysicals.AddLast(physicalOrderHandler.GetActiveOrders(symbol));
if (debug)
{
var next = originalLogicals.First;
for (var node = next; node != null; node = node.Next)
{
var order = node.Value;
log.Debug("Logical Order: " + order);
}
}
if (debug)
{
var next = originalPhysicals.First;
for (var node = next; node != null; node = node.Next)
{
var order = node.Value;
log.Debug("Physical Order: " + order);
}
}
if (CheckForPending())
{
if (debug)
{
log.Debug("Found pending physical orders. Skipping compare.");
}
return;
}
lock ( bufferedLogicalsLocker) {
if (CheckForFilledOrders(bufferedLogicals))
{
if (debug)
{
log.Debug("Found already filled orders in position change event. Skipping compare.");
}
return;
}
originalLogicals.Clear();
if (bufferedLogicals != null)
{
originalLogicals.AddLast(bufferedLogicals);
}
}
logicalOrders.Clear();
logicalOrders.AddLast(originalLogicals);
physicalOrders.Clear();
if (originalPhysicals != null)
{
physicalOrders.AddLast(originalPhysicals);
}
PhysicalOrder physical;
extraLogicals.Clear();
while (logicalOrders.Count > 0)
{
var logical = logicalOrders.First.Value;
if (TryMatchId(logical, out physical))
{
ProcessMatch(logical, physical);
physicalOrders.Remove(physical);
}
else
{
extraLogicals.Add(logical);
}
logicalOrders.Remove(logical);
}
// Find any pending adjustments.
int pendingAdjustments = FindPendingAdjustments();
if (trace)
{
log.Trace("Found " + physicalOrders.Count + " extra physicals.");
}
int cancelCount = 0;
while (physicalOrders.Count > 0)
{
physical = physicalOrders.First.Value;
if (ProcessExtraPhysical(physical))
{
cancelCount++;
}
physicalOrders.Remove(physical);
}
if (cancelCount > 0)
{
// Wait for cancels to complete before creating any orders.
return;
}
if (TrySyncPosition(pendingAdjustments))
{
// Wait for fill to process before creating any orders.
return;
}
if (trace)
{
log.Trace("Found " + extraLogicals.Count + " extra logicals.");
}
while (extraLogicals.Count > 0)
{
var logical = extraLogicals[0];
ProcessExtraLogical(logical);
extraLogicals.Remove(logical);
}
}
public void AddOrder(LogicalOrder order)
{
allOrders.AddLast(order);
}
public void AddOrder(LogicalOrder order)
{
Context.AddOrder(order);
allOrders.AddLast(order);
ordersHash.Add(order.Id, order);
}
public void LinkedListTest()
{
ActiveList <TestItem> linked = new ActiveList <TestItem>();
List <TestItem> list = new List <TestItem>();
int size = 1000;
int iterations = 100000;
for (int i = 0; i < size; i++)
{
linked.AddLast(new TestItem());
list.Add(new TestItem());
}
long startTime = Factory.TickCount;
for (int j = 0; j < iterations; j++)
{
for (int i = 0; i < list.Count; i++)
{
TestItem item = list[i];
item.Number += 2;
}
}
long endTime = Factory.TickCount;
log.Notice("for list took " + (endTime - startTime));
startTime = Factory.TickCount;
for (int j = 0; j < iterations; j++)
{
foreach (var item in list)
{
item.Number += 2;
}
}
endTime = Factory.TickCount;
log.Notice("foreach list took " + (endTime - startTime));
startTime = Factory.TickCount;
for (int j = 0; j < iterations; j++)
{
foreach (var item in linked)
{
item.Number += 2;
}
}
endTime = Factory.TickCount;
log.Notice("foreach linked took " + (endTime - startTime));
startTime = Factory.TickCount;
for (int j = 0; j < iterations; j++)
{
for (var node = linked.First; node != null; node = node.Next)
{
node.Value.Number += 2;
}
}
endTime = Factory.TickCount;
log.Notice("for on linked took " + (endTime - startTime));
startTime = Factory.TickCount;
for (int j = 0; j < iterations; j++)
{
var next = linked.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
node.Value.Number += 2;
}
}
endTime = Factory.TickCount;
log.Notice("lambda on linked took " + (endTime - startTime));
}