IOrder (JForex API 2.13.99 API)

```
public interface IOrder
```
Contains order data and allows order manipulation

Author:

Denis Larka

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class IOrder.State
Indicates state of the order

Nested Classes
Modifier and Type	Interface and Description
`static class`	`IOrder.State` Indicates state of the order

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`close()` Sends a request to fully close position by market price or cancel entry order.
`void`	`close(double amount)` Sends a request to close the position with specified amount, by market price and default slippage.
`void`	`close(double amount, double price)` Sends a request to close the position with specified amount, price and default slippage.
`void`	`close(double amount, double price, double slippage)` Sends a request to close the position with specified amount, price and slippage.
`boolean`	`compare(IOrder order)` Deprecated. use `Object.equals(Object)`
`double`	`getAmount()` Returns amount of the order.
`java.util.List<ICloseOrder>`	`getCloseHistory()` Returns ordered history of order closing.
`double`	`getClosePrice()` Returns price at which order was closed or 0 if order or order part wasn't closed.
`long`	`getCloseTime()` Returns time when server closed the order
`java.lang.String`	`getComment()` Returns comment that was set when order was submitted
`double`	`getCommission()` Return position's commission in account currency.
`double`	`getCommissionInUSD()` Return position's commission in USD
`long`	`getCreationTime()` Returns creation time.
`IEntryOrder`	`getEntryOrder()` Returns Entry Order data.
`java.util.List<IFillOrder>`	`getFillHistory()` Returns ordered history of order filling.
`long`	`getFillTime()` Returns time of the fill
`IFinancialInstrument`	`getFinancialInstrument()` Deprecated. use `getInstrument()`
`long`	`getGoodTillTime()` Returns time when order will be cancelled or 0 if order is "good till cancel"
`IEntryOrder`	`getGroupedEntryOrder()` Returns Entry Order data for second order in One Cancels the Other group.
`IStopLossOrder`	`getGroupedStopLossOrder()` Returns Stop Loss Order data for second order in One Cancels the Other group.
`ITakeProfitOrder`	`getGroupedTakeProfitOrder()` Returns Take Profit Order data for second order in One Cancels the Other group.
`java.lang.String`	`getId()` Returns position or entry ID
`Instrument`	`getInstrument()` Returns instrument of the order
`java.lang.String`	`getLabel()` Returns label
`double`	`getOpenPrice()` Returns entry level price for conditional orders in `IOrder.State.CREATED` and `IOrder.State.OPENED` state or price at which order was filled for orders in `IOrder.State.FILLED` or `IOrder.State.CLOSED` states
`IEngine.OrderCommand`	`getOrderCommand()` Returns `IEngine.OrderCommand` of this message.
`double`	`getOriginalAmount()` Returns original constant amount of the order.
`double`	`getProfitLossInAccountCurrency()` Returns profit/loss in account currency
`double`	`getProfitLossInPips()` Returns profit/loss in pips.
`double`	`getProfitLossInUSD()` Returns profit/loss in USD
`double`	`getRequestedAmount()` Returns requested amount
`IOrder.State`	`getState()` Returns current `IOrder.State` of the order
`IStopLossOrder`	`getStopLossOrder()` Returns Stop Loss Order data.
`double`	`getStopLossPrice()` Returns price of stop loss condition or 0 if stop loss condition is not set.
`OfferSide`	`getStopLossSide()` Returns side that is used to check stop loss condition
`ITakeProfitOrder`	`getTakeProfitOrder()` Returns Take Profit Order data.
`double`	`getTakeProfitPrice()` Returns price of take profit condition or 0 if take profit condition is not set.
`double`	`getTrailingStep()` Returns current trailing step or 0 if no trailing step is set
`void`	`groupToOco(IOrder second)` Adds this order with specified second order to One Cancels the Other group.
`boolean`	`isLong()` Returns true if order is LONG.
`boolean`	`isOCO()` Returns whether this order is One Cancels the Other order.
`void`	`setComment(java.lang.String comment)` Sets comment for pending orders.
`void`	`setGoodTillTime(long goodTillTime)` Sets "good till time" for BIDs, OFFERs and LIMIT orders.
`void`	`setLabel(java.lang.String label)` Sets label for entry orders.
`void`	`setOpenPrice(double price)` Sets open price for order in `IOrder.State.OPENED` state or pending part of partially filled order
`void`	`setOpenPrice(double price, double slippage)` Sets open price for order in `IOrder.State.OPENED` state or pending part of partially filled order
`void`	`setRequestedAmount(double amount)` Sets amount of order in `IOrder.State.OPENED` state or cancels pending part of partially filled order when amount equals to zero is set.
`void`	`setStopLossPrice(double price)` Sets stop loss price.
`void`	`setStopLossPrice(double price, OfferSide side)` Sets stop loss price.
`void`	`setStopLossPrice(double price, OfferSide side, double trailingStep)` Sets stop loss price.
`void`	`setTakeProfitPrice(double price)` Sets take profit price.
`void`	`ungroupOco()` Removes this order from One Cancels the Other group.
`IMessage`	`waitForUpdate(IOrder.State... states)` Blocks strategy thread (with exception of `IStrategy.onMessage(IMessage)`) until the order changes it's state value to one of the expected `states`.
`void`	`waitForUpdate(long timeoutMills)` Blocks strategy thread (with exception of `IStrategy.onMessage(IMessage)`) until the order changes it's state or any order value gets updated.
`IMessage`	`waitForUpdate(long timeoutMills, IOrder.State... states)` Blocks strategy thread (with exception of `IStrategy.onMessage(IMessage)`) until the order changes it's state value to one of the expected `states`.
`IMessage`	`waitForUpdate(long timeout, java.util.concurrent.TimeUnit unit)` Blocks strategy thread (with exception of `IStrategy.onMessage(IMessage)`) until the order changes it's state or any order value gets updated.
`IMessage`	`waitForUpdate(long timeout, java.util.concurrent.TimeUnit unit, IOrder.State... states)` Blocks strategy thread (with exception of `IStrategy.onMessage(IMessage)`) until the order changes it's state value to one of the expected `states`.

- Method Detail
  - getInstrument
```
Instrument getInstrument()
```
    Returns instrument of the order
    
    Returns:
    
    instrument
  - getLabel
```
java.lang.String getLabel()
```
    Returns label
    
    Returns:
    
    label
  - getId
```
java.lang.String getId()
```
    Returns position or entry ID
    
    Returns:
    
    id
  - getCreationTime
```
long getCreationTime()
```
    Returns creation time. This is the time when server accepted the order, not the time when it was submitted For global accounts it is always 0.
    
    Returns:
    
    creation time
  - getCloseTime
```
long getCloseTime()
```
    Returns time when server closed the order
    
    Returns:
    
    time when order was closed
  - getOrderCommand
```
IEngine.OrderCommand getOrderCommand()
```
    Returns IEngine.OrderCommand of this message. After the order fill returns IEngine.OrderCommand.BUY if the order is LONG, IEngine.OrderCommand.SELL otherwise.
    
    Returns:
    
    order command of this message
  - isLong
```
boolean isLong()
```
    Returns true if order is LONG. Equals to getOrderCommand().isLong()
    
    Returns:
    
    true if order is LONG
  - getFillTime
```
long getFillTime()
```
    Returns time of the fill
    
    Returns:
    
    time of the order fill
  - getOriginalAmount
```
double getOriginalAmount()
```
    Returns original constant amount of the order. The value is set on order submit and cannot be changed later.
    
    Returns:
    
    original amount of the order
    
    See Also:
    
    IEngine.submitOrder(String, Instrument, com.dukascopy.api.IEngine.OrderCommand, double)
  - getAmount
```
double getAmount()
```
    Returns amount of the order. For orders in IOrder.State.OPENED state returns amount requested. For orders in IOrder.State.FILLED state will return filled amount. Filled amount can be different from requested amount (partial fill).
    
    Returns:
    
    amount of the order
  - getRequestedAmount
```
double getRequestedAmount()
```
    Returns requested amount
    
    Returns:
    
    amount requested
  - getOpenPrice
```
double getOpenPrice()
```
    Returns entry level price for conditional orders in IOrder.State.CREATED and IOrder.State.OPENED state or price at which order was filled for orders in IOrder.State.FILLED or IOrder.State.CLOSED states
    
    Returns:
    
    entry level for conditional orders or open price for positions
  - getClosePrice
```
double getClosePrice()
```
    Returns price at which order was closed or 0 if order or order part wasn't closed. This is the price of latest close operation in case of partial close
    
    Returns:
    
    close price for closed orders, return 0 for any other type of order
  - getStopLossPrice
```
double getStopLossPrice()
```
    Returns price of stop loss condition or 0 if stop loss condition is not set. Orders submitted with stop loss condition, will have this price set only after server accepts order
    
    Returns:
    
    stop loss price or 0
  - getTakeProfitPrice
```
double getTakeProfitPrice()
```
    Returns price of take profit condition or 0 if take profit condition is not set. Orders submitted with take profit condition, will have this price set only after server accepts order
    
    Returns:
    
    take profit price or 0
  - setStopLossPrice
```
void setStopLossPrice(double price)
               throws JFException
```
    Sets stop loss price. If price is 0 or negative, then stop loss condition will be removed. Default stop loss side is BID for long orders and ASK for short. This method will send command to the server, getStopLossPrice() method will still return old value until server will accept this changes.
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server). Not applicable for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED
          || (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional())
  ) {
      order.setStopLossPrice(order.getOpenPrice() - instrument.getPipValue() * 20);
  }
 
```
    Parameters:
    
    price - price to set
    
    Throws:
    
    JFException - when method fails for some reason
  - setStopLossPrice
```
void setStopLossPrice(double price,
                      OfferSide side)
               throws JFException
```
    Sets stop loss price. If price is 0 or negative, then stop loss condition will be removed. This method will send command to the server, getStopLossPrice() method will still return old value until server will accept this changes
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server). Not applicable for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED
          || (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional())
  ) {
      order.setStopLossPrice(order.getOpenPrice() - instrument.getPipValue() * 20, OfferSide.BID);
  }
 
```
    Parameters:
    
    price - price to set
    
    side - side that will be used to check stop loss condition
    
    Throws:
    
    JFException - when method fails for some reason
  - setStopLossPrice
```
void setStopLossPrice(double price,
                      OfferSide side,
                      double trailingStep)
               throws JFException
```
    Sets stop loss price. If price is 0 or negative, then stop loss condition will be removed. If trailingStep is bigger than 10, then trailing step logic will be applied for stop loss price. This method will send command to the server, getStopLossPrice() method will still return old value until server will accept this changes
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server). Not applicable for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED
          || (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional())
  ) {
      order.setStopLossPrice(order.getOpenPrice() - instrument.getPipValue() * 20, OfferSide.BID, 10);
  }
 
```
    Parameters:
    
    price - price to set
    
    side - side that will be used to check stop loss condition
    
    trailingStep - if == 0 then adds stop loss order without trailing step. Should be 0 or ≥ 10
    
    Throws:
    
    JFException - trailingStep is > 0 and < 10 or when method fails for some reason
  - setLabel
```
void setLabel(java.lang.String label)
       throws JFException
```
    Sets label for entry orders.
    By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server).
```
  if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
      order.setLabel("new_"+order.getLabel());
  }
 
```
    Parameters:
    
    label - new label
    
    Throws:
    
    JFException - if order is not in IOrder.State.OPENED state or new label is null or empty
  - getStopLossSide
```
OfferSide getStopLossSide()
```
    Returns side that is used to check stop loss condition
    
    Returns:
    
    stop loss side
  - getTrailingStep
```
double getTrailingStep()
```
    Returns current trailing step or 0 if no trailing step is set
    
    Returns:
    
    trailing step value
  - setTakeProfitPrice
```
void setTakeProfitPrice(double price)
                 throws JFException
```
    Sets take profit price. If price is 0 or negative, then take profit condition will be removed. This method will send command to the server, getTakeProfitPrice() method will still return old value until server will accept this changes
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server). Not applicable for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED
          || (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional())
  ) {
      order.setTakeProfitPrice(order.getOpenPrice() + instrument.getPipValue() * 20);
  }
 
```
    Parameters:
    
    price - price to set
    
    Throws:
    
    JFException - when method fails for some reason
  - getComment
```
java.lang.String getComment()
```
    Returns comment that was set when order was submitted
    
    Returns:
    
    comment
  - setComment
```
void setComment(java.lang.String comment)
         throws JFException
```
    Sets comment for pending orders.
    By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server).
```
  if (order.getState() == IOrder.State.OPENED && order.getOrderCommand() != BUY && order.getOrderCommand() != SELL) {
      order.setComment("new_"+order.getComment());
  }
 
```
    Parameters:
    
    comment - comment text
    
    Throws:
    
    JFException - if order is not in IOrder.State.OPENED state
  - setRequestedAmount
```
void setRequestedAmount(double amount)
                 throws JFException
```
    Sets amount of order in IOrder.State.OPENED state or cancels pending part of partially filled order when amount equals to zero is set.
    By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server).
```
  if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
      order.setRequestedAmount(0); //cancel conditional order
  }
  
  if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
      order.setRequestedAmount(order.getAmount() * 2); //double the order amount
  }
 
```
    Parameters:
    
    amount - new amount
    
    Throws:
    JFException - when:
    
    Order is neither IOrder.State.OPENED nor IOrder.State.FILLED
    
    Order is IOrder.State.OPENED and amount is less than the minimum allowed and not 0
    
    Order is fully filled, i.e., in IOrder.State.FILLED and with getRequestedAmount()==getAmount()
    
    Order is partially filled, i.e., in IOrder.State.FILLED and the amount is not 0
  - setOpenPrice
```
void setOpenPrice(double price)
           throws JFException
```
    Sets open price for order in IOrder.State.OPENED state or pending part of partially filled order
    By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server).
```
 if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
     //raise open price by two pips
     order.setOpenPrice(order.getOpenPrice() + order.getInstrument().getPipValue() * 2);
 }
  
 if (order.getState() == IOrder.State.FILLED && order.getOrderCommand().isConditional()
         && order.getAmount() < order.getRequestedAmount()
 ) {
     //change open price for the UNFILLED part
     order.setOpenPrice(order.getOpenPrice() + order.getInstrument().getPipValue() * 2);
 }
 
```
    Parameters:
    
    price - price of the opening condition
    
    Throws:
    
    JFException - when price change fails
  - setOpenPrice
```
void setOpenPrice(double price,
                  double slippage)
           throws JFException
```
    Sets open price for order in IOrder.State.OPENED state or pending part of partially filled order
    By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server).
```
 if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
     //raise open price by two pips
     order.setOpenPrice(order.getOpenPrice() + order.getInstrument().getPipValue() * 2, 1);
 }

 if (order.getState() == IOrder.State.FILLED && order.getOrderCommand().isConditional()
         && order.getAmount() < order.getRequestedAmount()
 ) {
     //change open price for the UNFILLED part
     order.setOpenPrice(order.getOpenPrice() + order.getInstrument().getPipValue() * 2, 1);
 }
 
```
    Parameters:
    
    price - price of the opening condition
    slippage - required price slippage. The value of slippage means following:
    
    if negative then default value of 5 pips is used
    if Double.isNaN(slippage) == true then no slippage is used
    otherwise, slippage is set in pips, you should pass 1, not 0.0001
    Throws:
    
    JFException - when price change fails
  - close
```
void close(double amount,
           double price,
           double slippage)
    throws JFException
```
    Sends a request to close the position with specified amount, price and slippage. If order has both pending and filled parts and amount is greater than 0, only filled part will be closed. If amount is 0 then both filled and pending parts will be closed/canceled.
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. Full position close is not allowed for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED) {
       // conditional partial close by price, with default slippage of 1 pip
      double lastBid = history.getLastTick(instrument).getBid();
      order.close(0.003, lastBid - 1 * instrument.getPipValue(), 1);
  }
 
```
    Parameters:
    
    amount - closing amount. Can be less than opened amount, in this case partial close will take place. If 0 is provided then all amount will be closed
    
    price - required close price. Close will be rejected if no liquidity at this price. This parameter doesn't affect entry (conditional) orders.
    slippage - required price slippage. The value of slippage means following:
    
    if negative then default value of 5 pips is used
    if Double.isNaN(slippage) == true then no slippage is used
    otherwise, slippage is set in pips, you should pass 1, not 0.0001
    Throws:
    
    JFException - when called for order not in IOrder.State.OPENED or IOrder.State.FILLED state. And if order is IOrder.State.OPENED, but amount != 0 or price != 0 or slippage ≥ 0
  - close
```
void close(double amount,
           double price)
    throws JFException
```
    Sends a request to close the position with specified amount, price and default slippage. If order has both pending and filled parts and amount is greater than 0, only filled part will be closed. If amount is 0 then both filled and pending parts will be closed/canceled.
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. Full position close is not allowed for Global accounts. Note: default value of 5 pips slippage is used. To specify custom slippage, or disable slippage at all, please use extended close(...) methods.
```
  if (order.getState() == IOrder.State.FILLED) {
      // conditional partial close by price, with default slippage of 5 pips
      double lastBid = history.getLastTick(instrument).getBid();
      order.close(0.003, lastBid - 1 * instrument.getPipValue());
  }
 
```
    Parameters:
    
    amount - closing amount. Can be less than opened amount, in this case partial close will take place. If 0 is provided then all amount will be closed
    
    price - required close price. Close will be rejected if no liquidity at this price. This parameter doesn't affect entry (conditional) orders.
    
    Throws:
    
    JFException - when called for order not in IOrder.State.OPENED or IOrder.State.FILLED state. And if order is IOrder.State.OPENED, but amount != 0 or price != 0
  - close
```
void close(double amount)
    throws JFException
```
    Sends a request to close the position with specified amount, by market price and default slippage. If order has both pending and filled parts and amount is greater than 0, only filled part will be closed. If amount is 0 then both filled and pending parts will be closed/canceled.
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. Full position close is not allowed for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED) {
      // unconditional partial close
      order.close(order.getAmount() / 2);
  }
 
```
    Parameters:
    
    amount - closing amount. Can be less than opened amount, in this case partial close will take place. If 0 is provided then all amount will be closed
    
    Throws:
    
    JFException - when called for order not in IOrder.State.OPENED or IOrder.State.FILLED state. And if order is IOrder.State.OPENED, but amount != 0
  - close
```
void close()
    throws JFException
```
    Sends a request to fully close position by market price or cancel entry order. If order has both pending and filled parts, both will be closed/canceled.
    Applicable to orders of state IOrder.State.OPENED and IOrder.State.FILLED. Not allowed for Global accounts.
```
  if (order.getState() == IOrder.State.FILLED) {
      // unconditional close
      order.close();
  }
  
  if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
      // cancel conditional order
      order.close();
  }
 
```
    Throws:
    
    JFException - if order is not in IOrder.State.OPENED or IOrder.State.FILLED state
  - getState
```
IOrder.State getState()
```
    Returns current IOrder.State of the order
    
    Returns:
    
    state
  - setGoodTillTime
```
void setGoodTillTime(long goodTillTime)
              throws JFException
```
    Sets "good till time" for BIDs, OFFERs and LIMIT orders.
    Applicable to orders of state IOrder.State.OPENED. By default, may not be called on the same order more often than once per second (exact value of max order update per second is sent by server).
```
 //order "expires" 1 minute after its creation
 if (order.getState() == IOrder.State.OPENED && order.getOrderCommand().isConditional()) {
     order.setGoodTillTime(order.getCreationTime() + TimeUnit.MINUTES.toMillis(1));
 }
 
```
    Parameters:
    
    goodTillTime - time when BID, OFFER or LIMIT orders should be canceled
    
    Throws:
    
    JFException - when order is simple market order
  - getGoodTillTime
```
long getGoodTillTime()
```
    Returns time when order will be cancelled or 0 if order is "good till cancel"
    
    Returns:
    
    cancel time or 0
  - waitForUpdate
```
void waitForUpdate(long timeoutMills)
```
    Blocks strategy thread (with exception of IStrategy.onMessage(IMessage)) until the order changes it's state or any order value gets updated. All the ticks, bars and other feed elements that platform receives while waiting get dropped.
    The method should be used for imminent order updates (e.g., set stop loss, close order). Consequently it should not be used for non-imminent order updates like order close on stop loss, conditional order fill, etc. The method must not be called from the IStrategy.onMessage(IMessage) method.
    See usage example at waitForUpdate(long, TimeUnit, State...)
    
    Parameters:
    
    timeoutMills - timeout to wait for order state change
  - waitForUpdate
```
IMessage waitForUpdate(long timeout,
                       java.util.concurrent.TimeUnit unit)
```
    Blocks strategy thread (with exception of IStrategy.onMessage(IMessage)) until the order changes it's state or any order value gets updated. All the ticks, bars and other feed elements that platform receives while waiting get dropped.
    The method should be used for imminent order updates (e.g., set stop loss, close order). Consequently it should not be used for non-imminent order updates like order close on stop loss, conditional order fill, etc. The method must not be called from the IStrategy.onMessage(IMessage) method.
    See usage example at waitForUpdate(long, TimeUnit, State...)
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    message generated as the result of order update or null if method exited by timeout
  - waitForUpdate
```
IMessage waitForUpdate(IOrder.State... states)
                throws JFException
```
    Blocks strategy thread (with exception of IStrategy.onMessage(IMessage)) until the order changes it's state value to one of the expected states. If states is empty, any order update will cause the thread unblocking. All the ticks, bars and other feed elements that platform receives while waiting get dropped.
    The method should be used for imminent order updates (e.g., set stop loss, close order). Consequently it should not be used for non-imminent order updates like order close on stop loss, conditional order fill, etc. The method must not be called from the IStrategy.onMessage(IMessage) method.
    See usage example at waitForUpdate(long, TimeUnit, State...)
    
    Parameters:
    
    states - a set of expected states. If null or empty - blocks until order changes it's state to any value.
    
    Returns:
    
    message generated as the result of order update. Can be null if method exited by timeout
    
    Throws:
    
    JFException - when order is in state that cannot be changed to one of expected states
  - waitForUpdate
```
IMessage waitForUpdate(long timeoutMills,
                       IOrder.State... states)
                throws JFException
```
    Blocks strategy thread (with exception of IStrategy.onMessage(IMessage)) until the order changes it's state value to one of the expected states. If states is empty, any order update will cause the thread unblocking. All the ticks, bars and other feed elements that platform receives while waiting get dropped.
    The method should be used for imminent order updates (e.g., set stop loss, close order). Consequently it should not be used for non-imminent order updates like order close on stop loss, conditional order fill, etc. The method must not be called from the IStrategy.onMessage(IMessage) method.
    See usage example at waitForUpdate(long, TimeUnit, State...)
    
    Parameters:
    
    timeoutMills - timeout to wait for order state change
    
    states - a set of expected states. If null or empty - blocks until order changes it's state to any value.
    
    Returns:
    
    message generated as the result of order update. Can be null if method exited by timeout
    
    Throws:
    
    JFException - when order is in state that cannot be changed to one of expected states
  - waitForUpdate
```
IMessage waitForUpdate(long timeout,
                       java.util.concurrent.TimeUnit unit,
                       IOrder.State... states)
                throws JFException
```
    Blocks strategy thread (with exception of IStrategy.onMessage(IMessage)) until the order changes it's state value to one of the expected states. If states is empty, any order update will cause the thread unblocking. All the ticks, bars and other feed elements that platform receives while waiting get dropped.
    The method should be used for imminent order updates (e.g., set stop loss, close order). Consequently it should not be used for non-imminent order updates like order close on stop loss, conditional order fill, etc. The method must not be called from the IStrategy.onMessage(IMessage) method.
```
 public void onStart(IContext context) throws JFException {
     IEngine engine = context.getEngine();
     IConsole console = context.getConsole();
     context.setSubscribedInstruments(java.util.Collections.singleton(Instrument.EURUSD), true);
          
     //submit order and await its fill data
     IOrder o = engine.submitOrder("order", Instrument.EURUSD, OrderCommand.BUY, 0.001);
     o.waitForUpdate(2, TimeUnit.SECONDS, IOrder.State.FILLED);   
     console.getOut().format("After fill: open price=%.5f, fill time=%s", o.getOpenPrice(), DateUtils.format(o.getFillTime())).println();
     
     //adjust stop loss to be in 5 pip distance from open price and await the assigned SL price
     o.setStopLossPrice(o.getOpenPrice() - 0.0005);
     //wait max 2 sec for SL price to get updated; note that we don't expect IOrder.State change here 
     o.waitForUpdate(2, TimeUnit.SECONDS); 
     console.getOut().format("After SL update: stop loss=%.5f", o.getStopLossPrice()).println();         
     }
 
```
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter.
    
    states - a set of expected states. If null or empty - blocks until order changes it's state to any value.
    
    Returns:
    
    message generated as the result of order update. Can be null if method exited by timeout
    
    Throws:
    
    JFException - when order is in state that cannot be changed to one of expected states
  - getProfitLossInPips
```
double getProfitLossInPips()
```
    Returns profit/loss in pips. The value is rounded to 0.1 pips.
    
    Returns:
    
    profit/loss in pips
  - getProfitLossInUSD
```
double getProfitLossInUSD()
```
    Returns profit/loss in USD
    
    Returns:
    
    profit/loss in USD
  - getProfitLossInAccountCurrency
```
double getProfitLossInAccountCurrency()
```
    Returns profit/loss in account currency
    
    Returns:
    
    profit/loss in account currency
  - getCommission
```
double getCommission()
```
    Return position's commission in account currency.
    For global accounts (i.e., IAccount.isGlobal()) returns the accumulated commission of the instrument's position that has been accumulated over the current trading session. Which means that the value gets reset with every platform reconnect.
    
    Returns:
    
    position's commission in account currency
  - getCommissionInUSD
```
double getCommissionInUSD()
```
    Return position's commission in USD
    For global accounts (i.e., IAccount.isGlobal()) returns the accumulated commission of the instrument's position that has been accumulated over the current trading session. Which means that the value gets reset with every platform reconnect.
    
    Returns:
    
    position's commission in USD
  - getFillHistory
```
java.util.List<IFillOrder> getFillHistory()
```
    Returns ordered history of order filling. History is sorted by fill time in ascending order.
    
    Returns:
    
    ascending ordered history of order filling
  - getCloseHistory
```
java.util.List<ICloseOrder> getCloseHistory()
```
    Returns ordered history of order closing. History is sorted by close time in ascending order.
    
    Returns:
    
    ascending ordered history of order closing
  - isOCO
```
boolean isOCO()
```
    Returns whether this order is One Cancels the Other order.
    
    Returns:
    
    true if this order is One Cancels the Other order.
  - groupToOco
```
void groupToOco(IOrder second)
         throws JFException
```
    Adds this order with specified second order to One Cancels the Other group.
    
    Parameters:
    
    second - second order in OCO group
    
    Throws:
    
    JFException - if orders can't be added to OCO group
  - ungroupOco
```
void ungroupOco()
         throws JFException
```
    Removes this order from One Cancels the Other group.
    
    Throws:
    
    JFException - if order can't be removed from OCO group
  - getEntryOrder
```
IEntryOrder getEntryOrder()
```
    Returns Entry Order data.
    
    Returns:
    
    entry order or null if order does not contain pending part
  - getStopLossOrder
```
IStopLossOrder getStopLossOrder()
```
    Returns Stop Loss Order data.
    
    Returns:
    
    stop loss order or null if stop loss condition was not specified
  - getTakeProfitOrder
```
ITakeProfitOrder getTakeProfitOrder()
```
    Returns Take Profit Order data.
    
    Returns:
    
    take profit order or null if take profit condition was not specified
  - getGroupedEntryOrder
```
IEntryOrder getGroupedEntryOrder()
```
    Returns Entry Order data for second order in One Cancels the Other group.
    
    Returns:
    
    entry order or null if order is not in OCO group
  - getGroupedStopLossOrder
```
IStopLossOrder getGroupedStopLossOrder()
```
    Returns Stop Loss Order data for second order in One Cancels the Other group.
    
    Returns:
    
    stop loss order or null if order is not in OCO group or stop loss condition was not specified
  - getGroupedTakeProfitOrder
```
ITakeProfitOrder getGroupedTakeProfitOrder()
```
    Returns Take Profit Order data for second order in One Cancels the Other group.
    
    Returns:
    
    take profit order or null if order is not in OCO group or take profit condition was not specified
  - compare
```
@Deprecated
boolean compare(IOrder order)
```
    Deprecated. use Object.equals(Object)
    
    Compares order to current one
    
    Parameters:
    
    order - to compare with current
    
    Returns:
    
    true if all fields are equal
  - getFinancialInstrument
```
@Deprecated
IFinancialInstrument getFinancialInstrument()
```
    Deprecated. use getInstrument()
    
    Returns instrument of the order
    
    Returns:
    
    financialInstrument

Interface IOrder

Nested Class Summary

Method Summary

Method Detail

getInstrument

getLabel

getId

getCreationTime

getCloseTime

getOrderCommand

isLong

getFillTime

getOriginalAmount

getAmount

getRequestedAmount

getOpenPrice

getClosePrice

getStopLossPrice

getTakeProfitPrice

setStopLossPrice

setStopLossPrice

setStopLossPrice

setLabel

getStopLossSide

getTrailingStep

setTakeProfitPrice

getComment

setComment

setRequestedAmount

setOpenPrice

setOpenPrice

close

close

close

close

getState

setGoodTillTime

getGoodTillTime

waitForUpdate

waitForUpdate

waitForUpdate

waitForUpdate

waitForUpdate

getProfitLossInPips

getProfitLossInUSD

getProfitLossInAccountCurrency

getCommission

getCommissionInUSD

getFillHistory

getCloseHistory

isOCO

groupToOco

ungroupOco

getEntryOrder

getStopLossOrder

getTakeProfitOrder

getGroupedEntryOrder

getGroupedStopLossOrder

getGroupedTakeProfitOrder

compare

getFinancialInstrument