void Items_ItemRemoved(object sender, ListEventArgs <ListBoxItem> e) { _itemContainer.Controls.Clear(); if (e.Item.Selected) { if (Multiselect) { _selected.Remove(e.Item); } else { SelectedItem = null; } } e.Item.Selected = false; e.Item.MouseClick -= item_MouseClick; e.Item.SelectedChanged -= Item_SelectedChanged; foreach (var item in Items) { _itemContainer.Controls.Add(item); } }
public override void OnChangeTrade(TransactionPairBinary comboTrade, LogicalFill fill, LogicalOrder filledOrder) { lastMidpoint = double.NaN; if (fill.Position % lotSize != 0) { return; } var size = Math.Abs(comboTrade.CurrentPosition); var change = size - lastSize; totalVolume += change; lastSize = size; if (change > 0) { fills.AddFirst(new LocalFill(change, fill.Price, fill.Time)); SetupBidAsk(fill.Price); } else { change = Math.Abs(change); for (var current = fills.First; current != null; current = current.Next) { var prevFill = current.Value; if (change > prevFill.Size) { change -= prevFill.Size; fills.Remove(current); if (fills.Count > 0) { SetupBidAsk(fill.Price); } } else { prevFill.Size -= change; if (prevFill.Size == 0) { fills.Remove(current); if (fills.Count > 0) { SetupBidAsk(fill.Price); } } break; } } } }
public void Change(double price, int positionChange) { InventoryGroupDefault changeInventory; if (positionChange > 0) { changeInventory = bidOwner; //if( maxInventories > 1) AdjustBidOffset(); } else if (positionChange < 0) { changeInventory = offerOwner; //if (maxInventories > 1) AdjustOfferOffset(); } else { throw new InvalidOperationException("Change position must be either greater or less than zero."); } changeInventory.Change(price, positionChange); if (changeInventory.Status == InventoryStatus.Flat) { changeInventory.Pause(); active.Remove(changeInventory); EnsureActiveInventory(); } }
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 void PopChanges(ActiveList <bTriangle> triangleList, ActiveList <bVertex> vertexList) { if (triangleStack.Count <= 0) { return; } runningbTriangleChanges = triangleStack[triangleStack.Count - 1]; triangleStack.RemoveAt(triangleStack.Count - 1); runningVertexChanges = vertexStack[vertexStack.Count - 1]; vertexStack.RemoveAt(vertexStack.Count - 1); runningbTriangleChanges.Reverse(); runningVertexChanges.Reverse(); foreach (bTriangle_Change t in runningbTriangleChanges) { if (t.oldData != null) { t.node.data = t.oldData; } if (t.activityToggle) { triangleList.SetActivity(t.node, !t.node.IsActive()); } if (t.newNode) { triangleList.Remove(t.node); } } foreach (Vertex_Change v in runningVertexChanges) { if (v.oldData != null) { v.node.data = v.oldData; } if (v.activityToggle) { vertexList.SetActivity(v.node, !v.node.IsActive()); } if (v.newNode) { vertexList.Remove(v.node); } } runningbTriangleChanges = new List <bTriangle_Change>(); runningVertexChanges = new List <Vertex_Change>(); }
public void destroyRenderedObject(GameObject activeObject, POICoordinatesObject poiCoordinatesObject) { ActiveList.Remove(activeObject); SpawnedObjects.Remove(poiCoordinatesObject); foreach (Transform objects in transform.parent) { if (objects.gameObject == activeObject) { Destroy(objects.gameObject); break; } } Debug.Log("Unloaded spawned Object"); }
public async void CompareNewBar(IAgg bar, string symbol) { var id = StockList.Where(e => e.Symbol == symbol).Select(e => e.Id).FirstOrDefault(); var itemFlags = ActiveList.Where(e => e.SymbolId == id).ToList(); foreach (var item in itemFlags) { if (item.IsActive == "Y") { if (item.ExpirationDate >= DateTime.Now) { if (item.ComparisonType == "GreaterThan") { if (item.AlertPrice >= bar.Close) { var xx = item.BuySellFlag; var emailList = await GetUserEmails(); EmailEngine.SendTradeAlert(emailList); //send alert, //remove active flag in table, ActiveList.Remove(item); } } else if (item.ComparisonType == "LessThan") { if (item.AlertPrice <= bar.Close) { ActiveList.Remove(item); } } } else { //send tracker expired email, //update active flag ActiveList.Remove(item); } } else { ActiveList.Remove(item); } } }
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); }
public void TestRemoveWhileReading() { for (var i = 0; i < 50; i++) { list.AddLast(Interlocked.Increment(ref nextValue)); } var next = list.First; var item = next.Value; for (var current = next; current != null; current = next) { next = current.Next; item = current.Value; if (item == 10) { list.Remove(next); } if (item == 35) { break; } } Assert.AreEqual(35, item, "found item"); }
private void ProcessFill(LogicalFillBinary fill, bool isCompletePhysicalFill) { if (debug) { log.Debug("ProcessFill() logical: " + fill); } int orderId = fill.OrderId; if (orderId == 0) { // This is an adjust-to-position market order. // Position gets set via SetPosition instead. return; } var filledOrder = FindLogicalOrder(orderId); if (debug) { log.Debug("Matched fill with order: " + filledOrder); } var isCompleteLogicalFill = filledOrder.Position == Math.Abs(fill.Position); if (filledOrder.TradeDirection == TradeDirection.Change) { var strategyPosition = filledOrder.StrategyPosition; var orderPosition = filledOrder.Type == OrderType.BuyLimit || filledOrder.Type == OrderType.BuyMarket || filledOrder.Type == OrderType.BuyStop ? filledOrder.Position : -filledOrder.Position; if (debug) { log.Debug("Change order fill = " + orderPosition + ", strategy = " + strategyPosition + ", fill = " + fill.Position); } isCompleteLogicalFill = orderPosition + strategyPosition == fill.Position; if (!isCompleteLogicalFill) { var change = fill.Position - filledOrder.StrategyPosition; filledOrder.Position = Math.Abs(orderPosition - change); if (debug) { log.Debug("Changing order to position: " + filledOrder.Position); } } } if (isCompleteLogicalFill) { try { if (debug) { log.Debug("Marking order id " + filledOrder.Id + " as completely filled."); } filledOrders.Add(filledOrder.SerialNumber, TimeStamp.UtcNow.Internal); originalLogicals.Remove(filledOrder); CleanupAfterFill(filledOrder); } catch (ApplicationException) { } } UpdateOrderCache(filledOrder, fill); if (onProcessFill != null) { if (debug) { log.Debug("Sending logical fill for " + symbol + ": " + fill); } onProcessFill(symbol, fill); } if (isCompletePhysicalFill && !isCompleteLogicalFill) { if (debug) { log.Debug("Found complete physical fill but incomplete logical fill."); } ProcessMissingPhysical(filledOrder); } if (isCompleteLogicalFill) { if (debug) { log.Debug("Performing extra compare."); } lock ( performCompareLocker) { PerformCompareInternal(); } } }
private void ProcessMatchPhysicalEntry(LogicalOrder logical, PhysicalOrder physical) { log.Trace("ProcessMatchPhysicalEntry()"); var strategyPosition = logical.StrategyPosition; var difference = logical.Position - Math.Abs(strategyPosition); log.Trace("position difference = " + difference); if (difference == 0) { TryCancelBrokerOrder(physical); } else if (difference != physical.Size) { var origBrokerOrder = physical.BrokerOrder; if (strategyPosition == 0) { physicalOrders.Remove(physical); var side = GetOrderSide(logical.Type); physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference); TryChangeBrokerOrder(physical, origBrokerOrder); } else { if (strategyPosition > 0) { if (logical.Type == OrderType.BuyStop || logical.Type == OrderType.BuyLimit) { physicalOrders.Remove(physical); var side = GetOrderSide(logical.Type); physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference); TryChangeBrokerOrder(physical, origBrokerOrder); } else { TryCancelBrokerOrder(physical); } } if (strategyPosition < 0) { if (logical.Type == OrderType.SellStop || logical.Type == OrderType.SellLimit) { physicalOrders.Remove(physical); var side = GetOrderSide(logical.Type); physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference); TryChangeBrokerOrder(physical, origBrokerOrder); } else { TryCancelBrokerOrder(physical); } } } } else if (logical.Price.ToLong() != physical.Price.ToLong()) { var origBrokerOrder = physical.BrokerOrder; physicalOrders.Remove(physical); var side = GetOrderSide(logical.Type); physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference); TryChangeBrokerOrder(physical, origBrokerOrder); } else { VerifySide(logical, physical); } }
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); } }