private void ProcessMatchPhysicalChangePriceAndSide(LogicalOrder logical, PhysicalOrder physical, int delta)
{
if (logical.Price.ToLong() != physical.Price.ToLong())
{
var origBrokerOrder = physical.BrokerOrder;
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
if (side == physical.Side)
{
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, Math.Abs(delta));
if (debug)
{
log.Debug("(Price) Changing " + origBrokerOrder + " to " + physical);
}
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
if (debug)
{
log.Debug("(Price) Canceling wrong side" + physical);
}
TryCancelBrokerOrder(physical);
}
}
else
{
VerifySide(logical, physical);
}
}
public void OnInitialize()
{
marketOrder = Factory.Engine.LogicalOrder(Strategy.Data.SymbolInfo, Strategy);
marketOrder.TradeDirection = TradeDirection.ExitStrategy;
marketOrder.Tag = "ExitStrategy";
Strategy.AddOrder(marketOrder);
breakEvenBuyStopOrder = Factory.Engine.LogicalOrder(Strategy.Data.SymbolInfo, Strategy);
breakEvenBuyStopOrder.TradeDirection = TradeDirection.ExitStrategy;
breakEvenBuyStopOrder.Type = OrderType.BuyStop;
breakEvenBuyStopOrder.Tag = "ExitStrategy";
Strategy.AddOrder(breakEvenBuyStopOrder);
breakEvenSellStopOrder = Factory.Engine.LogicalOrder(Strategy.Data.SymbolInfo, Strategy);
breakEvenSellStopOrder.TradeDirection = TradeDirection.ExitStrategy;
breakEvenSellStopOrder.Type = OrderType.SellStop;
breakEvenSellStopOrder.Tag = "ExitStrategy";
Strategy.AddOrder(breakEvenSellStopOrder);
buyStopLossOrder = Factory.Engine.LogicalOrder(Strategy.Data.SymbolInfo, Strategy);
buyStopLossOrder.TradeDirection = TradeDirection.ExitStrategy;
buyStopLossOrder.Type = OrderType.BuyStop;
buyStopLossOrder.Tag = "ExitStrategy";
Strategy.AddOrder(buyStopLossOrder);
sellStopLossOrder = Factory.Engine.LogicalOrder(Strategy.Data.SymbolInfo, Strategy);
sellStopLossOrder.TradeDirection = TradeDirection.ExitStrategy;
sellStopLossOrder.Type = OrderType.SellStop;
sellStopLossOrder.Tag = "ExitStrategy";
Strategy.AddOrder(sellStopLossOrder);
if (IsTrace)
{
Log.Trace(Strategy.FullName + ".Initialize()");
}
Strategy.Drawing.Color = Color.Black;
}
private void ProcessMissingPhysical(LogicalOrder logical, int size)
{
if (logical.StrategyPosition > 0)
{
if (logical.Type == OrderType.SellLimit ||
logical.Type == OrderType.SellStop ||
logical.Type == OrderType.SellMarket)
{
if (debug)
{
log.Debug("ProcessMissingPhysical(" + logical + ")");
}
var side = GetOrderSide(logical.Type);
var physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, size);
TryCreateBrokerOrder(physical);
}
}
if (logical.StrategyPosition < 0)
{
if (logical.Type == OrderType.BuyLimit ||
logical.Type == OrderType.BuyStop ||
logical.Type == OrderType.BuyMarket)
{
if (debug)
{
log.Debug("ProcessMissingPhysical(" + logical + ")");
}
var side = GetOrderSide(logical.Type);
var physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, size);
TryCreateBrokerOrder(physical);
}
}
}
private bool TryMatchTypeOnly(LogicalOrder logical, out PhysicalOrder physicalOrder)
{
double difference = logical.Position - Math.Abs(actualPosition);
foreach (var physical in originalPhysicals)
{
if (logical.Type == physical.Type)
{
if (logical.TradeDirection == TradeDirection.Entry)
{
if (difference != 0)
{
physicalOrder = physical;
return(true);
}
}
if (logical.TradeDirection == TradeDirection.Exit)
{
if (actualPosition != 0)
{
physicalOrder = physical;
return(true);
}
}
}
}
physicalOrder = default(PhysicalOrder);
return(false);
}
private void TryDrawTrade(LogicalOrder order, LogicalFill fill)
{
if (drawTrade != null && strategy != null && strategy.Performance.GraphTrades)
{
drawTrade(order, fill);
}
}
private void TryDrawTrade(LogicalOrder order, double price, double position)
{
if (drawTrade != null && graphTrades == true)
{
drawTrade(order, price, position);
}
}
public virtual void TestPositionSyncAndStopExits()
{
using (VerifyFeed verify = Factory.Utility.VerifyFeed(symbol))
using (Agent provider = ProviderFactory()) {
verify.PauseSeconds = secondsDelay;
provider.SendEvent(new EventItem(verify, null, EventType.Connect, null));
provider.SendEvent(new EventItem(verify, symbol, EventType.StartSymbol, new StartSymbolDetail(TimeStamp.MinValue)));
VerifyConnected(verify);
ClearOrders(0);
ClearPosition(provider, verify, secondsDelay);
TickIO lastTick = verify.LastTick;
double bid = lastTick.IsTrade ? lastTick.Price : lastTick.Bid;
double ask = lastTick.IsTrade ? lastTick.Price : lastTick.Ask;
int strategyPosition = 0;
CreateExit(strategy, OrderType.SellStop, bid - 180 * symbol.MinimumTick, strategyPosition);
LogicalOrder exitBuyStop = CreateExit(strategy, OrderType.BuyStop, ask + 540 * symbol.MinimumTick, strategyPosition);
var count = verify.Verify(2, assertTick, secondsDelay, () => {
SendOrders(provider, verify, 0, secondsDelay);
});
Assert.GreaterOrEqual(count, 2, "tick count");
ClearOrders(0);
ClearPosition(provider, verify, secondsDelay);
var expectedTicks = 1;
count = verify.Wait(expectedTicks, secondsDelay);
}
}
/// <summary>
/// Draws a trade and annotateg with hover message if possible.
/// </summary>
/// <param name="order"></param>
/// <param name="fillPrice"></param>
/// <param name="resultingPosition"></param>
/// <returns></returns>
public int DrawTrade(LogicalOrder order, double fillPrice, double resultingPosition)
{
Color color = Color.Empty;
ArrowDirection direction = ArrowDirection.Up;
switch (order.Type)
{
case OrderType.BuyLimit:
case OrderType.BuyStop:
case OrderType.BuyMarket:
color = Color.Green;
direction = ArrowDirection.Up;
break;
case OrderType.SellLimit:
case OrderType.SellStop:
case OrderType.SellMarket:
color = Color.Red;
direction = ArrowDirection.Down;
break;
default:
throw new ApplicationException("Unknown OrderType " + order.Type + " for drawing a trade.");
}
if (order.TradeDirection == TradeDirection.Exit ||
order.TradeDirection == TradeDirection.ExitStrategy)
{
color = Color.Black;
}
// One ticket open on tickzoom is to draw arrows to scale based
// on the price range of the chart. This numbers for size and position
// were hard code, calibrated to Forex prices.
ChartArrow chartArrow = CreateArrow(direction, color, 12.5f, ChartBars.BarCount, fillPrice);
var sb = new StringBuilder();
if (order.Tag != null)
{
sb.AppendLine(order.Tag.ToString());
}
sb.Append(order.TradeDirection);
sb.Append(" ");
sb.AppendLine(order.Type.ToString());
if (order.Price > 0)
{
sb.Append("at ");
sb.AppendLine(order.Price.ToString());
}
sb.Append("size ");
sb.AppendLine(order.Position.ToString());
sb.Append("filled ");
sb.AppendLine(fillPrice.ToString());
sb.Append("new positions ");
sb.AppendLine(resultingPosition.ToString());
chartArrow.Tag = sb.ToString();
objectId++;
graphObjs.Add(objectId, chartArrow);
return(objectId);
}
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);
}
private void ProcessMissingPhysical(LogicalOrder logical)
{
switch (logical.TradeDirection)
{
case TradeDirection.Entry:
if (debug)
{
log.Debug("ProcessMissingPhysicalEntry(" + logical + ")");
}
var side = GetOrderSide(logical.Type);
var physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, logical.Position);
TryCreateBrokerOrder(physical);
break;
case TradeDirection.Exit:
case TradeDirection.ExitStrategy:
var size = Math.Abs(logical.StrategyPosition);
ProcessMissingPhysical(logical, size);
break;
case TradeDirection.Reverse:
var logicalPosition =
logical.Type == OrderType.BuyLimit ||
logical.Type == OrderType.BuyMarket ||
logical.Type == OrderType.BuyStop ?
logical.Position : -logical.Position;
size = Math.Abs(logicalPosition - logical.StrategyPosition);
if (size != 0)
{
ProcessMissingPhysical(logical, size);
}
break;
case TradeDirection.Change:
logicalPosition =
logical.Type == OrderType.BuyLimit ||
logical.Type == OrderType.BuyMarket ||
logical.Type == OrderType.BuyStop ?
logical.Position : -logical.Position;
logicalPosition += logical.StrategyPosition;
size = Math.Abs(logicalPosition - logical.StrategyPosition);
if (size != 0)
{
if (debug)
{
log.Debug("ProcessMissingPhysical(" + logical + ")");
}
side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, size);
TryCreateBrokerOrder(physical);
}
break;
default:
throw new ApplicationException("Unknown trade direction: " + logical.TradeDirection);
}
}
public void CanDecreasePriority()
{
var x = new LogicalOrder(100);
x = x.PushBackBy(50);
var y = new LogicalOrder(100);
Assert.IsTrue(x < y);
}
public void CanIncreasePriority()
{
var x = new LogicalOrder(100);
x = x.BringForwardBy(50);
var y = new LogicalOrder(100);
Assert.IsTrue(x > y);
}
private void ProcessMatchPhysicalReverse(LogicalOrder logical, PhysicalOrder physical)
{
var strategyPosition = logical.StrategyPosition;
var logicalPosition =
logical.Type == OrderType.BuyLimit ||
logical.Type == OrderType.BuyMarket ||
logical.Type == OrderType.BuyStop ?
logical.Position : -logical.Position;
var physicalPosition =
physical.Side == OrderSide.Buy ?
physical.Size : -physical.Size;
var delta = logicalPosition - strategyPosition;
var difference = delta - physicalPosition;
if (delta == 0 || strategyPosition == 0 ||
strategyPosition > 0 && logicalPosition > 0 ||
strategyPosition < 0 && logicalPosition < 0)
{
TryCancelBrokerOrder(physical);
}
else if (difference != 0)
{
var origBrokerOrder = physical.BrokerOrder;
if (delta > 0)
{
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, OrderSide.Buy, Math.Abs(delta));
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
OrderSide side;
if (strategyPosition > 0 && logicalPosition < 0)
{
side = OrderSide.Sell;
delta = strategyPosition;
if (delta == physical.Size)
{
ProcessMatchPhysicalChangePriceAndSide(logical, physical, delta);
return;
}
}
else
{
side = OrderSide.SellShort;
}
side = (long)strategyPosition >= (long)Math.Abs(delta) ? OrderSide.Sell : OrderSide.SellShort;
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, Math.Abs(delta));
TryChangeBrokerOrder(physical, origBrokerOrder);
}
}
else
{
ProcessMatchPhysicalChangePriceAndSide(logical, physical, delta);
}
}
private void UpdateOrderCache(LogicalOrder order, LogicalFill fill)
{
var strategyPosition = (StrategyPosition)order.Strategy;
if (debug)
{
log.Debug("Adjusting strategy position to " + order.Position + ", strategy position was " + strategyPosition.Position);
}
strategyPosition.Position = fill.Position;
// orderCache.RemoveInactive(order);
}
private void VerifySide(LogicalOrder logical, PhysicalOrder physical)
{
var side = GetOrderSide(logical.Type);
if (physical.Side != side)
{
TryCancelBrokerOrder(physical);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, physical.Size);
TryCreateBrokerOrder(physical);
}
}
private bool PlaceOrder(LimeFIXProvider target, SymbolInfo symbol, OrderType type,
int size, double price, out LogicalOrder logicalOrder, out CreateOrChangeOrderDefault priceOrder)
{
logicalOrder = Factory.Engine.LogicalOrder(symbol);
logicalOrder.TradeDirection = TradeDirection.Entry;
logicalOrder.Type = type;
logicalOrder.Price = price;
logicalOrder.Position = size;
priceOrder = new CreateOrChangeOrderDefault(OrderAction.Create, symbol, logicalOrder, OrderSide.Buy, logicalOrder.Position, logicalOrder.Price);
return(target.OnCreateBrokerOrder(priceOrder));
}
private bool TryMatchId(LogicalOrder logical, out PhysicalOrder physicalOrder)
{
foreach (var physical in originalPhysicals)
{
if (logical.Id == physical.LogicalOrderId)
{
physicalOrder = physical;
return(true);
}
}
physicalOrder = default(PhysicalOrder);
return(false);
}
public PhysicalOrderDefault(OrderState orderState, SymbolInfo symbol, LogicalOrder logical, OrderSide side, int size)
{
this.orderState = orderState;
this.symbol = symbol;
this.side = side;
this.type = logical.Type;
this.price = logical.Price;
this.size = size;
this.logicalOrderId = logical.Id;
this.logicalSerialNumber = logical.SerialNumber;
this.tag = logical.Tag;
this.reference = null;
this.replace = null;
this.brokerOrder = CreateBrokerOrderId(logicalOrderId);
}
private void ProcessMatchPhysicalReversePriceAndSide(LogicalOrder logical, PhysicalOrder physical, int delta)
{
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, Math.Abs(delta));
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
VerifySide(logical, physical);
}
}
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 void ProcessFill(StrategyInterface strategyInterface, LogicalFill fill)
{
if (debug)
{
Log.Debug("ProcessFill: " + fill + " for strategy " + strategyInterface);
}
var strategy = (Strategy)strategyInterface;
int orderId = fill.OrderId;
LogicalOrder filledOrder = null;
if (strategyInterface.TryGetOrderById(fill.OrderId, out filledOrder))
{
if (debug)
{
Log.Debug("Matched fill with orderId: " + orderId);
}
if (!doStrategyOrders && filledOrder.TradeDirection != TradeDirection.ExitStrategy)
{
if (debug)
{
Log.Debug("Skipping fill, strategy order fills disabled.");
}
return;
}
if (!doExitStrategyOrders && filledOrder.TradeDirection == TradeDirection.ExitStrategy)
{
if (debug)
{
Log.Debug("Skipping fill, exit strategy orders fills disabled.");
}
return;
}
TryDrawTrade(filledOrder, fill.Price, fill.Position);
if (debug)
{
Log.Debug("Changed strategy position to " + fill.Position + " because of fill.");
}
changePosition(strategy.Data.SymbolInfo, fill);
}
else
{
throw new ApplicationException("A fill for order id: " + orderId + " was incorrectly routed to: " + strategyInterface.Name);
}
}
public void TestLogicalStopOrders()
{
using (VerifyFeed verify = Factory.Utility.VerifyFeed())
using (Provider provider = ProviderFactory()) {
verify.PauseSeconds = secondsDelay;
provider.SendEvent(verify, null, (int)EventType.Connect, null);
provider.SendEvent(verify, symbol, (int)EventType.StartSymbol, new StartSymbolDetail(TimeStamp.MinValue));
VerifyConnected(verify);
ClearOrders(0);
ClearPosition(provider, verify, secondsDelay);
// var expectedTicks = 1;
// var count = verify.Wait(symbol,expectedTicks,secondsDelay);
// Assert.GreaterOrEqual(count,expectedTicks,"at least one tick");
TickIO lastTick = verify.LastTick;
double bid = lastTick.IsTrade ? lastTick.Price : lastTick.Bid;
double ask = lastTick.IsTrade ? lastTick.Price : lastTick.Ask;
int strategyPosition = 0;
LogicalOrder enterBuyStop = CreateEntry(strategy, OrderType.BuyStop, bid + 420 * symbol.MinimumTick, 2, strategyPosition);
LogicalOrder enterSellStop = CreateEntry(strategy, OrderType.SellStop, bid - 400 * symbol.MinimumTick, 2, strategyPosition);
CreateExit(strategy, OrderType.SellStop, bid - 180 * symbol.MinimumTick, strategyPosition);
LogicalOrder exitBuyStop = CreateExit(strategy, OrderType.BuyStop, ask + 540 * symbol.MinimumTick, strategyPosition);
var count = verify.Verify(2, assertTick, symbol, secondsDelay, () => {
SendOrders(provider, verify, 0, secondsDelay);
});
Assert.GreaterOrEqual(count, 2, "tick count");
ClearOrders(0);
enterSellStop.Price = bid - 360 * symbol.MinimumTick;
enterBuyStop.Price = ask + 380 * symbol.MinimumTick;
orders.AddLast(enterBuyStop);
orders.AddLast(enterSellStop);
orders.AddLast(exitBuyStop);
count = verify.Verify(2, assertTick, symbol, secondsDelay, () => {
SendOrders(provider, verify, 0, secondsDelay);
});
Assert.GreaterOrEqual(count, 2, "tick count");
// ClearOrders(0);
// ClearPosition(provider,verify,secondsDelay);
}
}
public void TestLogicalLimitOrders()
{
using (VerifyFeed verify = Factory.Utility.VerifyFeed(symbol))
using (Agent provider = ProviderFactory()) {
verify.PauseSeconds = secondsDelay;
provider.SendEvent(new EventItem(verify, null, EventType.Connect, null));
provider.SendEvent(new EventItem(verify, symbol, EventType.StartSymbol, new StartSymbolDetail(TimeStamp.MinValue)));
VerifyConnected(verify);
ClearOrders(0);
ClearPosition(provider, verify, secondsDelay);
TickIO lastTick = verify.LastTick;
double bid = lastTick.IsTrade ? lastTick.Price : lastTick.Bid;
double ask = lastTick.IsTrade ? lastTick.Price : lastTick.Ask;
int strategyPosition = 0;
LogicalOrder enterBuyLimit = CreateEntry(strategy, OrderType.BuyLimit, bid - 280 * symbol.MinimumTick, 2, strategyPosition);
LogicalOrder enterSellLimit = CreateEntry(strategy, OrderType.SellLimit, ask + 340 * symbol.MinimumTick, 2, strategyPosition);
LogicalOrder exitSellLimit = CreateExit(strategy, OrderType.SellLimit, ask + 380 * symbol.MinimumTick, strategyPosition);
CreateExit(strategy, OrderType.SellLimit, ask + 400 * symbol.MinimumTick, strategyPosition);
CreateExit(strategy, OrderType.BuyLimit, bid - 150 * symbol.MinimumTick, strategyPosition);
LogicalOrder exitBuyStop = CreateExit(strategy, OrderType.BuyStop, ask + 540 * symbol.MinimumTick, strategyPosition);
var count = verify.Verify(2, assertTick, secondsDelay, () => {
SendOrders(provider, verify, 0, secondsDelay);
});
Assert.GreaterOrEqual(count, 2, "tick count");
ClearOrders(0);
enterBuyLimit.Price = bid - 260 * symbol.MinimumTick;
enterSellLimit.Price = ask + 280 * symbol.MinimumTick;
orders.AddLast(enterBuyLimit);
orders.AddLast(enterSellLimit);
orders.AddLast(exitSellLimit);
count = verify.Verify(2, assertTick, secondsDelay, () => {
SendOrders(provider, verify, 0, secondsDelay);
});
Assert.GreaterOrEqual(count, 2, "tick count");
ClearOrders(0);
//ClearPosition(provider,verify,secondsDelay);
count = verify.Wait(1, secondsDelay);
}
}
private void ActiveOrdersChanged(LogicalOrder order)
{
if (trace)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Active Orders:");
foreach (var item in activeOrders)
{
sb.Append(" ");
sb.AppendLine(item.ToString());
}
sb.AppendLine("NextBar Orders:");
foreach (var item in nextBarOrders)
{
sb.Append(" ");
sb.AppendLine(item.ToString());
}
log.Trace("Order #" + order.Id + " was modified while position = " + position.Current + "\n" + sb);
sb.AppendLine();
}
}
public CreateOrChangeOrderDefault(OrderState orderState, SymbolInfo symbol, LogicalOrder logical, OrderSide side, int size, double price)
{
binary.action = OrderAction.Create;
OrderState = orderState;
binary.lastModifyTime = Factory.Parallel.UtcNow;
binary.symbol = symbol;
binary.side = side;
binary.type = logical.Type;
binary.price = price;
binary.size = size;
binary.logicalOrderId = logical.Id;
binary.logicalSerialNumber = logical.SerialNumber;
binary.tag = logical.Tag;
binary.reference = null;
binary.replacedBy = null;
binary.originalOrder = null;
binary.brokerOrder = CreateBrokerOrderId();
binary.utcCreateTime = logical.UtcChangeTime;
binary.orderFlags = logical.OrderFlags;
instanceId = ++nextInstanceId;
}
private void ProcessMatchPhysicalExitStrategy(LogicalOrder logical, PhysicalOrder physical)
{
var strategyPosition = logical.StrategyPosition;
if (strategyPosition == 0)
{
TryCancelBrokerOrder(physical);
}
else if (Math.Abs(strategyPosition) != physical.Size || 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, Math.Abs(strategyPosition));
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
VerifySide(logical, physical);
}
}
private void ProcessMatch(LogicalOrder logical, PhysicalOrder physical)
{
if (trace)
{
log.Trace("Process Match()");
}
if (physical.OrderState == OrderState.Suspended)
{
if (debug)
{
log.Trace("Cannot change a suspended order: " + physical);
}
return;
}
switch (logical.TradeDirection)
{
case TradeDirection.Entry:
ProcessMatchPhysicalEntry(logical, physical);
break;
case TradeDirection.Exit:
ProcessMatchPhysicalExit(logical, physical);
break;
case TradeDirection.ExitStrategy:
ProcessMatchPhysicalExitStrategy(logical, physical);
break;
case TradeDirection.Reverse:
ProcessMatchPhysicalReverse(logical, physical);
break;
case TradeDirection.Change:
ProcessMatchPhysicalChange(logical, physical);
break;
default:
throw new ApplicationException("Unknown TradeDirection: " + logical.TradeDirection);
}
}
private void ProcessExtraLogical(LogicalOrder logical)
{
// When flat, allow entry orders.
switch (logical.TradeDirection)
{
case TradeDirection.Entry:
if (logical.StrategyPosition == 0)
{
ProcessMissingPhysical(logical);
}
break;
case TradeDirection.Exit:
case TradeDirection.ExitStrategy:
if (logical.StrategyPosition != 0)
{
ProcessMissingPhysical(logical);
}
break;
case TradeDirection.Reverse:
if (logical.StrategyPosition != 0)
{
ProcessMissingPhysical(logical);
}
break;
case TradeDirection.Change:
if (logical.StrategyPosition != 0)
{
ProcessMissingPhysical(logical);
}
break;
default:
throw new ApplicationException("Unknown trade direction: " + logical.TradeDirection);
}
}
private void flattenSignal(LogicalOrder order, Tick tick)
{
// Actual fills of exit strategy orders now handles via the OrderManager interceptor.
// if (Strategy.Performance.GraphTrades)
// {
// double fillPrice = 0;
// if( position.IsLong) {
// order.Positions = context.Position.Size;
// fillPrice = tick.Bid;
// }
// if( position.IsShort) {
// order.Positions = context.Position.Size;
// fillPrice = tick.Ask;
// }
// Strategy.Chart.DrawTrade(order, fillPrice, 0);
// }
// position.Change(0);
// CancelOrders();
// if( controlStrategy) {
// Strategy.Orders.Exit.ActiveNow.GoFlat();
// strategySignal = 0;
// }
}
private void ActiveOrdersChanged(LogicalOrder order)
{
if (trace)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Active Orders:");
var next = activeOrders.First;
for (var current = next; current != null; current = next)
{
next = current.Next;
var item = current.Value;
sb.Append(" ");
sb.AppendLine(item.ToString());
}
sb.AppendLine("NextBar Orders:");
foreach (var item in nextBarOrders)
{
sb.Append(" ");
sb.AppendLine(item.ToString());
}
instanceLog.Trace("Order #" + order.Id + " was modified while position = " + position.Current + "\n" + sb);
sb.AppendLine();
}
}
public void AddOrder(LogicalOrder order)
{
throw new NotImplementedException();
}
