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)); }