IHistory (JForex API 2.13.99 API)

```
public interface IHistory
```
The IHistory interface represents API for historical data access.

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`IBar`	`getBar(IFinancialInstrument financialInstrument, Period period, OfferSide side, int shift)` Deprecated.
`IBar`	`getBar(Instrument instrument, Period period, OfferSide side, int shift)` Returns bar for specified instrument, period and side, that is shifted back in time for number in bars specified in `shift` parameter, 0 - current bar (currently generated from ticks), 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null.
`java.util.List<IBar>`	`getBars(IFinancialInstrument financialInstrument, Period period, OfferSide side, Filter filter, int numberOfCandlesBefore, long time, int numberOfCandlesAfter)` Deprecated.
`java.util.List<IBar>`	`getBars(IFinancialInstrument financialInstrument, Period period, OfferSide side, Filter filter, long from, long to)` Deprecated.
`java.util.List<IBar>`	`getBars(IFinancialInstrument financialInstrument, Period period, OfferSide side, long from, long to)` Deprecated.
`java.util.List<IBar>`	`getBars(Instrument instrument, Period period, OfferSide side, Filter filter, int numberOfCandlesBefore, long time, int numberOfCandlesAfter)` Returns bars for specified instrument, period and side.
`java.util.List<IBar>`	`getBars(Instrument instrument, Period period, OfferSide side, Filter filter, long from, long to)` Returns bars for specified instrument, period, side and filter.
`java.util.List<IBar>`	`getBars(Instrument instrument, Period period, OfferSide side, long from, long to)` Returns bars for specified instrument, period and side.
`long`	`getBarStart(Period period, long time)` Returns starting time of the bar that includes time specified in `time` parameter
`double`	`getEquity()` Returns current equity calculated for every tick
`ITimedData`	`getFeedData(IFeedDescriptor feedDescriptor, int shift)` Returns bar for specified feed descriptor, that is shifted back in time for number in bars specified in `shift` parameter, 0 - current bar (currently generated), 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null.
`java.util.List<ITimedData>`	`getFeedData(IFeedDescriptor feedDescriptor, int numberOfFeedBarsBefore, long time, int numberOfFeedBarsAfter)` Returns bars for specified feedDescriptor.
`java.util.List<ITimedData>`	`getFeedData(IFeedDescriptor feedDescriptor, long from, long to)` Returns bars for specified feed descriptor.
`ITimedData`	`getFeedData(IFeedInfo feedInfo, int shift)` Deprecated.
`java.util.List<ITimedData>`	`getFeedData(IFeedInfo feedInfo, int numberOfFeedBarsBefore, long time, int numberOfFeedBarsAfter)` Deprecated.
`java.util.List<ITimedData>`	`getFeedData(IFeedInfo feedInfo, long from, long to)` Deprecated.
`<T extends ITimedData> T`	`getFeedData(ITailoredFeedDescriptor<T> feedDescriptor, int shift)` A type-safe feed data retrieval for the specified feed
`<T extends ITimedData> java.util.List<T>`	`getFeedData(ITailoredFeedDescriptor<T> feedDescriptor, int numberOfFeedBarsBefore, long time, int numberOfFeedBarsAfter)` A type-safe feed data retrieval for the specified feed
`<T extends ITimedData> java.util.List<T>`	`getFeedData(ITailoredFeedDescriptor<T> feedDescriptor, long from, long to)` A type-safe feed data retrieval for the specified feed
`<T extends ITimedData> T`	`getFeedData(ITailoredFeedInfo<T> feedInfo, int shift)` A type-safe feed data retrieval for the specified feed
`<T extends ITimedData> java.util.List<T>`	`getFeedData(ITailoredFeedInfo<T> feedInfo, int numberOfFeedBarsBefore, long time, int numberOfFeedBarsAfter)` Deprecated.
`<T extends ITimedData> java.util.List<T>`	`getFeedData(ITailoredFeedInfo<T> feedInfo, long from, long to)` Deprecated.
`IOrder`	`getHistoricalOrderById(java.lang.String id)` Returns historical (closed) order by position id for the given user account.
`ITick`	`getLastTick(IFinancialInstrument financialInstrument)` Deprecated.
`ITick`	`getLastTick(Instrument instrument)` Returns last tick for specified instrument
`long`	`getNextBarStart(Period period, long barTime)` Returns starting time of the bar next to the bar that includes time specified in `barTime` parameter
`java.util.List<IOrder>`	`getOpenOrders(IFinancialInstrument financialInstrument, long from, long to)` Deprecated.
`java.util.List<IOrder>`	`getOpenOrders(Instrument instrument, long from, long to)` Returns open orders for specified instrument and time interval.
`java.util.List<IOrder>`	`getOrdersHistory(IFinancialInstrument financialInstrument, long from, long to)` Deprecated.
`java.util.List<IOrder>`	`getOrdersHistory(Instrument instrument, long from, long to)` Returns orders for specified instrument and time interval.
`IPointAndFigure`	`getPointAndFigure(Instrument instrument, OfferSide offerSide, PriceRange boxSize, ReversalAmount reversalAmount, int shift)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int)`.
`java.util.List<IPointAndFigure>`	`getPointAndFigures(Instrument instrument, OfferSide offerSide, PriceRange boxSize, ReversalAmount reversalAmount, int numberOfBarsBefore, long time, int numberOfBarsAfter)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int, long, int)`.
`java.util.List<IPointAndFigure>`	`getPointAndFigures(Instrument instrument, OfferSide offerSide, PriceRange boxSize, ReversalAmount reversalAmount, long from, long to)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, long, long)`.
`long`	`getPreviousBarStart(Period period, long barTime)` Returns starting time of the bar previous to the bar that includes time specified in `barTime` parameter
`IRangeBar`	`getRangeBar(Instrument instrument, OfferSide offerSide, PriceRange priceRange, int shift)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int)`.
`java.util.List<IRangeBar>`	`getRangeBars(Instrument instrument, OfferSide offerSide, PriceRange priceRange, int numberOfBarsBefore, long time, int numberOfBarsAfter)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int, long, int)`.
`java.util.List<IRangeBar>`	`getRangeBars(Instrument instrument, OfferSide offerSide, PriceRange priceRange, long from, long to)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, long, long)`.
`IRenkoBar`	`getRenkoBar(Instrument instrument, OfferSide offerSide, PriceRange brickSize, int shift)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int)`.
`java.util.List<IRenkoBar>`	`getRenkoBars(Instrument instrument, OfferSide offerSide, PriceRange brickSize, int numberOfBarsBefore, long time, int numberOfBarsAfter)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int, long, int)`.
`java.util.List<IRenkoBar>`	`getRenkoBars(Instrument instrument, OfferSide offerSide, PriceRange brickSize, long from, long to)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, long, long)`.
`long`	`getStartTimeOfCurrentBar(IFinancialInstrument financialInstrument, Period period)` Deprecated.
`long`	`getStartTimeOfCurrentBar(Instrument instrument, Period period)` Returns starting time of the current bar (bar currently generated from ticks) for specified instrument and period.
`ITick`	`getTick(IFinancialInstrument financialInstrument, int shift)` Deprecated.
`ITick`	`getTick(Instrument instrument, int shift)` Returns tick for specified instrument, that is shifted back in time for number in ticks specified in `shift` parameter, 0 - current tick, 1 - previous tick.
`ITickBar`	`getTickBar(Instrument instrument, OfferSide offerSide, TickBarSize tickBarSize, int shift)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int)`.
`java.util.List<ITickBar>`	`getTickBars(Instrument instrument, OfferSide offerSide, TickBarSize tickBarSize, int numberOfBarsBefore, long time, int numberOfBarsAfter)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, int, long, int)`.
`java.util.List<ITickBar>`	`getTickBars(Instrument instrument, OfferSide offerSide, TickBarSize tickBarSize, long from, long to)` Deprecated. use `getFeedData(ITailoredFeedDescriptor, long, long)`.
`java.util.List<ITick>`	`getTicks(IFinancialInstrument financialInstrument, int numberOfOneSecondIntervalsBefore, long time, int numberOfOneSecondIntervalsAfter)` Deprecated.
`java.util.List<ITick>`	`getTicks(IFinancialInstrument financialInstrument, long from, long to)` Deprecated.
`java.util.List<ITick>`	`getTicks(Instrument instrument, int numberOfOneSecondIntervalsBefore, long time, int numberOfOneSecondIntervalsAfter)` Returns ticks for specified instrument, time and count.
`java.util.List<ITick>`	`getTicks(Instrument instrument, long from, long to)` Returns ticks for specified instrument and time interval.
`long`	`getTimeForNBarsBack(Period period, long to, int numberOfBars)` Returns starting time of the bar that is `numberOfBars - 1` back in time to the bar that includes time specified in `to` parameter.
`long`	`getTimeForNBarsForward(Period period, long from, int numberOfBars)` Returns starting time of the bar that is + `numberOfBars - 1` in the future to the bar that includes time specified in `from` parameter.
`long`	`getTimeOfLastTick(IFinancialInstrument financialInstrument)` Deprecated.
`long`	`getTimeOfLastTick(Instrument instrument)` Returns time of last tick received for specified instrument.
`void`	`readBars(IFinancialInstrument financialInstrument, Period period, OfferSide side, Filter filter, int numberOfCandlesBefore, long time, int numberOfCandlesAfter, DataLoadingListener barListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readBars(IFinancialInstrument financialInstrument, Period period, OfferSide side, Filter filter, long from, long to, DataLoadingListener barListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readBars(IFinancialInstrument financialInstrument, Period period, OfferSide side, long from, long to, DataLoadingListener barListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readBars(Instrument instrument, Period period, OfferSide side, Filter filter, int numberOfCandlesBefore, long time, int numberOfCandlesAfter, LoadingDataListener barListener, LoadingProgressListener loadingProgress)` Reads bars from the local cache in the background.
`void`	`readBars(Instrument instrument, Period period, OfferSide side, Filter filter, long from, long to, LoadingDataListener barListener, LoadingProgressListener loadingProgress)` Reads bars from the local cache in the background.
`void`	`readBars(Instrument instrument, Period period, OfferSide side, long from, long to, LoadingDataListener barListener, LoadingProgressListener loadingProgress)` Reads bars from the local cache in the background.
`void`	`readFeedData(IFeedDescriptor feedDescriptor, int numberOfFeedDataBefore, long time, int numberOfFeedDataAfter, IFeedListener feedListener, LoadingProgressListener loadingProgress)` Reads feed data from the local cache in the background.
`void`	`readFeedData(IFeedDescriptor feedDescriptor, long from, long to, IFeedListener feedListener, LoadingProgressListener loadingProgress)` Reads feed data from the local cache in the background.
`<T extends ITimedData> void`	`readFeedData(IFeedInfo feedInfo, int numberOfFeedDataBefore, long time, int numberOfFeedDataAfter, IFinancialFeedListener financialFeedListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readFeedData(IFeedInfo feedInfo, long from, long to, IFinancialFeedListener feedListener, LoadingProgressListener loadingProgress)` Deprecated.
`<T extends ITimedData> void`	`readFeedData(ITailoredFeedDescriptor<T> feedDescriptor, int numberOfFeedDataBefore, long time, int numberOfFeedDataAfter, ITailoredFeedListener<T> feedListener, LoadingProgressListener loadingProgress)` A type-safe feed data retrieval for the specified feed
`<T extends ITimedData> java.util.stream.Stream<T>`	`readFeedData(ITailoredFeedDescriptor<T> feedDescriptor, int numberOfFeedDataBefore, long time, int numberOfFeedDataAfter, LoadingProgressListener loadingProgressListener)` A type-safe feed data retrieval for the specified feed.
`<T extends ITimedData> void`	`readFeedData(ITailoredFeedDescriptor<T> feedDescriptor, long from, long to, ITailoredFeedListener<T> feedListener, LoadingProgressListener loadingProgress)` A type-safe feed data retrieval for the specified feed
`<T extends ITimedData> java.util.stream.Stream<T>`	`readFeedData(ITailoredFeedDescriptor<T> feedDescriptor, long from, long to, LoadingProgressListener loadingProgressListener)` A type-safe feed data retrieval for the specified feed.
`<T extends ITimedData> void`	`readFeedData(ITailoredFeedInfo<T> feedInfo, int numberOfFeedDataBefore, long time, int numberOfFeedDataAfter, ITailoredFinancialFeedListener<T> tailoredFinancialFeedListener, LoadingProgressListener loadingProgress)` Deprecated.
`<T extends ITimedData> void`	`readFeedData(ITailoredFeedInfo<T> feedInfo, long from, long to, ITailoredFinancialFeedListener<T> tailoredFinancialFeedListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readOrdersHistory(IFinancialInstrument financialInstrument, long from, long to, OrdersLoadingListener ordersListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readOrdersHistory(Instrument instrument, long from, long to, LoadingOrdersListener ordersListener, LoadingProgressListener loadingProgress)` Loads orders from the server in the background.
`void`	`readPointAndFigures(Instrument instrument, OfferSide offerSide, PriceRange boxSize, ReversalAmount reversalAmount, int numberOfBarsBefore, long time, int numberOfBarsAfter, IPointAndFigureFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readPointAndFigures(Instrument instrument, OfferSide offerSide, PriceRange boxSize, ReversalAmount reversalAmount, long from, long to, IPointAndFigureFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readRangeBars(Instrument instrument, OfferSide offerSide, PriceRange priceRange, int numberOfBarsBefore, long time, int numberOfBarsAfter, IRangeBarFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readRangeBars(Instrument instrument, OfferSide offerSide, PriceRange priceRange, long from, long to, IRangeBarFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readRenkoBars(Instrument instrument, OfferSide offerSide, PriceRange brickSize, int numberOfBarsBefore, long time, int numberOfBarsAfter, IRenkoBarFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readRenkoBars(Instrument instrument, OfferSide offerSide, PriceRange brickSize, long from, long to, IRenkoBarFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readTickBars(Instrument instrument, OfferSide offerSide, TickBarSize tickBarSize, int numberOfBarsBefore, long time, int numberOfBarsAfter, ITickBarFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readTickBars(Instrument instrument, OfferSide offerSide, TickBarSize tickBarSize, long from, long to, ITickBarFeedListener listener, LoadingProgressListener loadingProgress)` Deprecated. use `readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener)`.
`void`	`readTicks(IFinancialInstrument financialInstrument, int numberOfOneSecondIntervalsBefore, long time, int numberOfOneSecondIntervalsAfter, LoadingDataListener tickListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readTicks(IFinancialInstrument financialInstrument, long from, long to, DataLoadingListener tickListener, LoadingProgressListener loadingProgress)` Deprecated.
`void`	`readTicks(Instrument instrument, int numberOfOneSecondIntervalsBefore, long time, int numberOfOneSecondIntervalsAfter, LoadingDataListener tickListener, LoadingProgressListener loadingProgress)` Reads ticks from the local cache in the background.
`void`	`readTicks(Instrument instrument, long from, long to, LoadingDataListener tickListener, LoadingProgressListener loadingProgress)` Reads ticks from the local cache in the background.

- Method Detail
  - getTimeOfLastTick
```
long getTimeOfLastTick(Instrument instrument)
                throws JFException
```
    Returns time of last tick received for specified instrument. Returns -1 if no tick was received yet.
    
    Parameters:
    
    instrument - instrument of the tick
    
    Returns:
    
    time of last tick or -1 if no tick was received
    
    Throws:
    
    JFException - when instrument is not active (not opened in platform)
  - getLastTick
```
ITick getLastTick(Instrument instrument)
           throws JFException
```
    Returns last tick for specified instrument
    
    Parameters:
    
    instrument - instrument of the tick
    
    Returns:
    
    tick
    
    Throws:
    
    JFException - when instrument is not active (not opened in platform)
  - getStartTimeOfCurrentBar
```
long getStartTimeOfCurrentBar(Instrument instrument,
                              Period period)
                       throws JFException
```
    Returns starting time of the current bar (bar currently generated from ticks) for specified instrument and period. If no tick was received for this instrument, then returns -1.
    
    Parameters:
    
    instrument - instrument of the bar
    
    period - period of the bar
    
    Returns:
    
    starting time of the current bar or -1 if no tick was received
    
    Throws:
    
    JFException - when period is not supported or instrument is not active (not opened in platform)
  - getBar
```
IBar getBar(Instrument instrument,
            Period period,
            OfferSide side,
            int shift)
     throws JFException
```
    Returns bar for specified instrument, period and side, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar (currently generated from ticks), 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null.
    consider getting the previous one hour bar
```
 IBar prevBar = history.getBar(Instrument.EURUSD, Period.ONE_HOUR, OfferSide.BID, 1);
 console.getOut().println(prevBar);    
 
```
    Parameters:
    
    instrument - instrument of the bar
    
    period - period of the bar
    
    side - bid or ask side of the bar
    
    shift - number of candle back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    bar or null if no bar is loaded
    
    Throws:
    
    JFException - when period is not supported or instrument is not active (not opened in platform)
  - readTicks
```
void readTicks(Instrument instrument,
               long from,
               long to,
               LoadingDataListener tickListener,
               LoadingProgressListener loadingProgress)
        throws JFException
```
    Reads ticks from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, ticks will be returned by calling methods in tickListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error. This method has two main purposes: one is to load a lot of ticks without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last days ticks - namely calculating the average ask price and the maximum bid
```
 private IHistory history;
 private IConsole console;

 double maxBid = Double.MIN_VALUE, avgAsk = 0;
 int tickCount =0;
 private Instrument instrument = Instrument.EURUSD;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     final long from = history.getLastTick(instrument).getTime() - Period.DAILY.getInterval();
     final long to = history.getLastTick(instrument).getTime();

     history.readTicks(instrument, from, to,

     new LoadingDataListener() {
          @Override
         public void newTick(Instrument instrument, long time, double ask, double bid, double askVol, double bidVol) {
             tickCount++;
             maxBid = Math.max(bid, maxBid);
             avgAsk = tickCount == 1 ? ask : round(avgAsk + ((avgAsk - ask) / (double)tickCount));
         }
         
         private double round(double amount) { 
             return (new BigDecimal(amount)).setScale(instrument.getPipScale(), BigDecimal.ROUND_HALF_UP).doubleValue();
         }

          @Override
         public void newBar(Instrument instrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             // no bars expected
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s ticks %s - %s max Bid=%.5f average ask=%.5f", 
                     tickCount, DateUtils.format(from), DateUtils.format(to), maxBid, avgAsk).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     });
 }
 
```
    Parameters:
    
    instrument - instrument of the ticks
    
    from - start of the time interval for which ticks should be loaded
    
    to - end time of the time interval for which ticks should be loaded. If there is tick with time equals to the time in to parameter then it will be loaded as well
    
    tickListener - receives data about requested ticks
    
    loadingProgress - used to control loading process
    
    Throws:
    
    JFException - when some error occurs while creating internal request for data
  - readTicks
```
void readTicks(Instrument instrument,
               int numberOfOneSecondIntervalsBefore,
               long time,
               int numberOfOneSecondIntervalsAfter,
               LoadingDataListener tickListener,
               LoadingProgressListener loadingProgress)
        throws JFException
```
    Reads ticks from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, ticks will be returned by calling method in tickListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of ticks without keeping them all in memory, and second is asynchronous processing
    
    Parameters:
    
    instrument - instrument of the ticks
    
    numberOfOneSecondIntervalsBefore - how much one second interval of ticks to load before and including one second interval of ticks with time specified in time parameter
    
    time - time of the last one second tick interval in period specified in numberOfOneSecondIntervalsBefore parameter or/and time of the one second tick interval prior first one second tick interval in period specified with numberOfOneSecondIntervalsAfter parameter
    
    numberOfOneSecondIntervalsAfter - how much one second tick intervals to load after (not including) one second tick interval with time specified in time parameter
    
    tickListener - receives data about requested ticks
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
  - readBars
```
void readBars(Instrument instrument,
              Period period,
              OfferSide side,
              long from,
              long to,
              LoadingDataListener barListener,
              LoadingProgressListener loadingProgress)
       throws JFException
```
    Reads bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in barListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last weeks 1 minute bars - namely calculating the average close price and the maximum bar size
```
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;
 private Instrument instrument = Instrument.EURUSD;
 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     long lastTickTime = history.getLastTick(instrument).getTime();
     final long from = history.getBarStart(period, lastTickTime - Period.DAILY.getInterval() * 7);
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(instrument, period, OfferSide.BID, from, to,

     new LoadingDataListener() {
          @Override
         public void newTick(Instrument instrument, long time, double ask, double bid, double askVol, double bidVol) {}

          @Override
         public void newBar(Instrument instrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             barCount++;
             maxHeight = Math.max(Math.abs(open - close), maxHeight);
             avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
             if(close - open > 0){
                 greenCount++;
             }
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s %s candles (%s green, %s red) %s  - %s max bar height=%.1fpips average close=%.5f"
                     barCount, period, greenCount, barCount - greenCount, DateUtils.format(from), DateUtils.format(to), maxHeight/instrument.getPipValue(), avgClose).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     });
 }
 
```
    Parameters:
    
    instrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for bar that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last bar to be loaded
    
    barListener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when period is not supported or time interval is not valid for specified period
    
    See Also:
    
    getBarStart(Period, long)
  - readBars
```
void readBars(Instrument instrument,
              Period period,
              OfferSide side,
              Filter filter,
              long from,
              long to,
              LoadingDataListener barListener,
              LoadingProgressListener loadingProgress)
       throws JFException
```
    Reads bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in barListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last weeks 1 minute bars - namely calculating the average close price and the maximum bar size
```
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;
 private Instrument instrument = Instrument.EURUSD;
 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     long lastTickTime = history.getLastTick(instrument).getTime();
     final long from = history.getBarStart(period, lastTickTime - Period.DAILY.getInterval() * 7);
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(instrument, period, OfferSide.BID, Filter.WEEKENDS, from, to,

     new LoadingDataListener() {
          @Override
         public void newTick(Instrument instrument, long time, double ask, double bid, double askVol, double bidVol) {}

          @Override
         public void newBar(Instrument instrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             barCount++;
             maxHeight = Math.max(Math.abs(open - close), maxHeight);
             avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
             if(close - open > 0){
                 greenCount++;
             }
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s %s candles (%s green, %s red) %s  - %s max bar height=%.1fpips average close=%.5f"
                     barCount, period, greenCount, barCount - greenCount, DateUtils.format(from), DateUtils.format(to), maxHeight/instrument.getPipValue(), avgClose).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     });
 }
 
```
    Parameters:
    
    instrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - bars filtering method see Filter
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for bar that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last bar to be loaded
    
    barListener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when period is not supported or time interval is not valid for specified period
    
    See Also:
    
    getBarStart(Period, long)
  - readBars
```
void readBars(Instrument instrument,
              Period period,
              OfferSide side,
              Filter filter,
              int numberOfCandlesBefore,
              long time,
              int numberOfCandlesAfter,
              LoadingDataListener barListener,
              LoadingProgressListener loadingProgress)
       throws JFException
```
    Reads bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in barListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the 100000 1 minute bars - namely calculating the average close price and the maximum bar size
```
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;
 private Instrument instrument = Instrument.EURUSD;
 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     long lastTickTime = history.getLastTick(instrument).getTime();
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(instrument, period, OfferSide.BID, Filter.WEEKENDS, 100000, to, 0,

     new LoadingDataListener() {
          @Override
         public void newTick(Instrument instrument, long time, double ask, double bid, double askVol, double bidVol) {}

          @Override
         public void newBar(Instrument instrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             barCount++;
             maxHeight = Math.max(Math.abs(open - close), maxHeight);
             avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
             if(close - open > 0){
                 greenCount++;
             }
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s %s candles (%s green, %s red) till %s max bar height=%.1fpips average close=%.5f",
                     barCount, period, greenCount, barCount - greenCount, DateUtils.format(to), maxHeight/instrument.getPipValue(), avgClose).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     });
 }
 
```
    Parameters:
    
    instrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - allows to filter candles
    
    numberOfCandlesBefore - how much candles to load before and including candle with time specified in time parameter
    
    time - time of the last candles in period specified in numberOfCandlesBefore parameter or/and time of the candle prior first candle in period specified with numberOfCandlesAfter parameter
    
    numberOfCandlesAfter - how much candles to load after (not including) candle with time specified in time parameter
    
    barListener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when period is not supported or time interval is not valid for specified period
    
    See Also:
    
    getBarStart(Period, long)
  - getTicks
```
java.util.List<ITick> getTicks(Instrument instrument,
                               long from,
                               long to)
                        throws JFException
```
    Returns ticks for specified instrument and time interval. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
```
 ITick lastTick = history.getLastTick(Instrument.EURUSD);
 List <ITick> ticks = history.getTicks(Instrument.EURUSD, lastTick.getTime() - 10 * 1000, lastTick.getTime());
 int last = ticks.size() - 1;
 console.getOut().format(
     "Tick count=%s; Latest bid price=%.5f, time=%s; Oldest bid price=%.5f, time=%s", 
     ticks.size(), ticks.get(last).getBid(), DateUtils.format(ticks.get(last).getTime()), ticks.get(0).getBid(), DateUtils.format(ticks.get(last).getTime())
 ).println();
 
```
    Parameters:
    
    instrument - instrument of the ticks
    
    from - start of the time interval for which ticks should be loaded
    
    to - end time of the time interval for which ticks should be loaded. If there is tick with time equals to the time in to parameter then it will be loaded as well
    
    Returns:
    
    loaded ticks
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getTicks
```
java.util.List<ITick> getTicks(Instrument instrument,
                               int numberOfOneSecondIntervalsBefore,
                               long time,
                               int numberOfOneSecondIntervalsAfter)
                        throws JFException
```
    Returns ticks for specified instrument, time and count. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    
    Parameters:
    
    instrument - instrument of the ticks
    
    numberOfOneSecondIntervalsBefore - how much one second interval of ticks to load before and including one second interval of ticks with time specified in time parameter
    
    time - time of the last one second tick interval in period specified in numberOfOneSecondIntervalsBefore parameter or/and time of the one second tick interval prior first one second tick interval in period specified with numberOfOneSecondIntervalsAfter parameter
    
    numberOfOneSecondIntervalsAfter - how much one second tick intervals to load after (not including) one second tick interval with time specified in time parameter
    
    Returns:
    
    loaded ticks
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getBars
```
java.util.List<IBar> getBars(Instrument instrument,
                             Period period,
                             OfferSide side,
                             long from,
                             long to)
                      throws JFException
```
    Returns bars for specified instrument, period and side. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    Consider getting 5 bars over a time interval:
```
 long prevBarTime = history.getPreviousBarStart(Period.ONE_HOUR, history.getLastTick(Instrument.EURUSD).getTime());
 long startTime =  history.getTimeForNBarsBack(Period.ONE_HOUR, prevBarTime, 5);  
 List <IBar> bars = history.getBars(Instrument.EURUSD, Period.ONE_HOUR, OfferSide.BID, startTime, prevBarTime);
 int last = bars.size() - 1;
 console.getOut().format(
          "Previous bar close price=%.5f; 4th to previous bar close price=%.5f", 
          bars.get(last).getClose(), bars.get(0).getClose()
 ).println();
 
```
    Consider getting daily bars over several months:
```
 SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyy HH:mm:ss"); 
 dateFormat.setTimeZone(TimeZone.getTimeZone("GMT")); 
 Date dateFrom, dateTo;
 try { 
     dateFrom = dateFormat.parse("04/06/2013 00:00:00"); 
     dateTo = dateFormat.parse("04/10/2013 00:00:00");
 } catch (ParseException e) {
     e.printStackTrace();
     return;
 }    
 List <IBar> bars = history.getBars(Instrument.EURUSD, Period.DAILY, OfferSide.ASK, dateFrom.getTime(), dateTo.getTime());
 console.getOut().format("bar FROM=%s; bar TO=%s", bars.get(0), bars.get(bars.size() - 1)).println();
 
```
    Parameters:
    
    instrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for candle that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last candle to be loaded
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when period is not supported or some error occurs when loading data
  - getBars
```
java.util.List<IBar> getBars(Instrument instrument,
                             Period period,
                             OfferSide side,
                             Filter filter,
                             long from,
                             long to)
                      throws JFException
```
    Returns bars for specified instrument, period, side and filter. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    
    Parameters:
    
    instrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - bars filtering method see Filter
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for candle that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last candle to be loaded
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when period is not supported or some error occurs when loading data
  - getBars
```
java.util.List<IBar> getBars(Instrument instrument,
                             Period period,
                             OfferSide side,
                             Filter filter,
                             int numberOfCandlesBefore,
                             long time,
                             int numberOfCandlesAfter)
                      throws JFException
```
    Returns bars for specified instrument, period and side. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException. If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included even if it's flat
    Consider getting 5 bars over a candle interval:
```
 long prevBarTime = history.getPreviousBarStart(Period.ONE_HOUR, history.getLastTick(Instrument.EURUSD).getTime());
 List <IBar> bars = history.getBars(Instrument.EURUSD, Period.ONE_HOUR, OfferSide.BID, Filter.NO_FILTER, 5, prevBarTime, 0);
 int last = bars.size() - 1;
 console.getOut().format(
         "Previous bar close price=%.5f; 4th to previous bar close price=%.5f", 
         bars.get(last).getClose(), bars.get(0).getClose()).println();
 
```
    Parameters:
    
    instrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - allows to filter candles
    
    numberOfCandlesBefore - how much candles to load before and including candle with time specified in time parameter
    
    time - time of the last candle in period specified in numberOfCandlesBefore parameter, or time of the first candle in period specified with numberOfCandlesAfter parameter if numberOfCandlesBefore is 0, or time of the candle prior to first candle in period specified with numberOfCandlesAfter if numberOfCandlesBefore is > 0
    
    numberOfCandlesAfter - how much candles to load after (not including) candle with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when period is not supported or some error occurs when loading data
  - getBarStart
```
long getBarStart(Period period,
                 long time)
          throws JFException
```
    Returns starting time of the bar that includes time specified in time parameter
    
    Parameters:
    
    period - period of the bar
    
    time - time that is included by the bar
    
    Returns:
    
    starting time of the bar
    
    Throws:
    
    JFException - when period is not supported
  - getNextBarStart
```
long getNextBarStart(Period period,
                     long barTime)
              throws JFException
```
    Returns starting time of the bar next to the bar that includes time specified in barTime parameter
    
    Parameters:
    
    period - period of the bar
    
    barTime - time that is included by the bar previous to the returned
    
    Returns:
    
    starting time of the bar
    
    Throws:
    
    JFException - when period is not supported
  - getPreviousBarStart
```
long getPreviousBarStart(Period period,
                         long barTime)
                  throws JFException
```
    Returns starting time of the bar previous to the bar that includes time specified in barTime parameter
    
    Parameters:
    
    period - period to the bar
    
    barTime - time that is included by the bar next to the returned
    
    Returns:
    
    staring time of the bar
    
    Throws:
    
    JFException - when period is not supported
  - getTimeForNBarsBack
```
long getTimeForNBarsBack(Period period,
                         long to,
                         int numberOfBars)
                  throws JFException
```
    Returns starting time of the bar that is numberOfBars - 1 back in time to the bar that includes time specified in to parameter. Method can be used to get time for the from parameter for getBars(com.dukascopy.api.Instrument, com.dukascopy.api.Period, com.dukascopy.api.OfferSide, long, long) method when is known time of the last bar and number of candles that needs to be loaded
    
    Parameters:
    
    period - period of the bars
    
    to - time of the last bar
    
    numberOfBars - number of bars that could be loaded when passing returned time and time specified in to parameter in getBars(com.dukascopy.api.Instrument, com.dukascopy.api.Period, com.dukascopy.api.OfferSide, long, long) method
    
    Returns:
    
    starting time of the bar
    
    Throws:
    
    JFException - when period is not supported
  - getTimeForNBarsForward
```
long getTimeForNBarsForward(Period period,
                            long from,
                            int numberOfBars)
                     throws JFException
```
    Returns starting time of the bar that is + numberOfBars - 1 in the future to the bar that includes time specified in from parameter. Method can be used to get time for the to parameter for getBars(com.dukascopy.api.Instrument, com.dukascopy.api.Period, com.dukascopy.api.OfferSide, long, long) method when is known time of the first bar and number of candles that needs to be loaded
    
    Parameters:
    
    period - period of the bars
    
    from - time of the first bar
    
    numberOfBars - number of bars that could be loaded when passing returned time and time specified in from parameter in getBars(com.dukascopy.api.Instrument, com.dukascopy.api.Period, com.dukascopy.api.OfferSide, long, long) method
    
    Returns:
    
    starting time of the last bar
    
    Throws:
    
    JFException - when period is not supported
  - readOrdersHistory
```
void readOrdersHistory(Instrument instrument,
                       long from,
                       long to,
                       LoadingOrdersListener ordersListener,
                       LoadingProgressListener loadingProgress)
                throws JFException
```
    Loads orders from the server in the background. Method returns fast after creating request for data not waiting for any data to be loaded After internal request is sent, orders will be returned by calling method in ordersListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method can be used for orders loading without blocking strategy execution NB! Only one order history request can be sent at a time. If there is another request sent method will throw JFException
    
    Parameters:
    
    instrument - instrument of the orders
    
    from - start of the time interval for which orders should be loaded
    
    to - end time of the time interval for which orders should be loaded
    
    ordersListener - receives data about requested orders
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - in case of any system error
    
    See Also:
    
    getOrdersHistory(Instrument instrument, long from, long to)
  - getOrdersHistory
```
java.util.List<IOrder> getOrdersHistory(Instrument instrument,
                                        long from,
                                        long to)
                                 throws JFException
```
    Returns orders for specified instrument and time interval. Method blocks until all data will be loaded from the server. NB! Only one order history request can be sent at a time. If there is another request sent method will throw JFException
    
    Parameters:
    
    instrument - instrument of the orders
    
    from - start of the time interval for which orders should be loaded
    
    to - end time of the time interval for which orders should be loaded
    
    Returns:
    
    loaded orders
    
    Throws:
    
    JFException - in case of any system error
  - getHistoricalOrderById
```
IOrder getHistoricalOrderById(java.lang.String id)
                       throws JFException
```
    Returns historical (closed) order by position id for the given user account.
    
    Parameters:
    
    id - closed order's position id
    
    Returns:
    
    historical (closed) order with specified position id for the given user account or null if there is no one.
    
    Throws:
    
    JFException - in case of any system error
  - getOpenOrders
```
java.util.List<IOrder> getOpenOrders(Instrument instrument,
                                     long from,
                                     long to)
```
    Returns open orders for specified instrument and time interval.
    
    Parameters:
    
    instrument - instrument of the orders
    
    from - start of the time interval for which orders should be loaded
    
    to - end time of the time interval for which orders should be loaded
    
    Returns:
    
    open orders
  - getEquity
```
double getEquity()
```
    Returns current equity calculated for every tick
    
    Returns:
    
    actual equity
  - getTick
```
ITick getTick(Instrument instrument,
              int shift)
       throws JFException
```
    Returns tick for specified instrument, that is shifted back in time for number in ticks specified in shift parameter, 0 - current tick, 1 - previous tick.
```
 ITick tick0 = history.getTick(Instrument.EURUSD, 0);
 ITick tick1 = history.getTick(Instrument.EURUSD, 1);
 console.getOut().format("last tick: %s; previous tick: %s", tick0, tick1).println();   
 
```
    Parameters:
    
    instrument - instrument of the tick
    
    shift - number of tick back in time staring from current tick. 1 - previous tick, 2 - current tick minus 2 ticks and so on
    
    Returns:
    
    tick
    
    Throws:
    
    JFException - when instrument is not active (not opened in platform) or other errors
  - getFeedData
```
ITimedData getFeedData(IFeedDescriptor feedDescriptor,
                       int shift)
                throws JFException
```
    Returns bar for specified feed descriptor, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar (currently generated), 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null.
    
    Parameters:
    
    feedDescriptor - holds parameters: data type, instrument, offer side, etc (depends on bar type), and describes what kind of bars must be loaded
    
    shift - number of bars back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    bar or null if no bar is loaded, the type of returning bar depends on FeedDescriptor.getDataType()
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getFeedData
```
<T extends ITimedData> T getFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                     int shift)
                              throws JFException
```
    A type-safe feed data retrieval for the specified feed
    
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor for corresponding data type
    
    shift - number of bars back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    bar or null if no bar is loaded
    
    Throws:
    
    JFException - when some error occurs when loading data
    
    See Also:
    
    getFeedData(IFeedDescriptor, int)
  - getFeedData
```
<T extends ITimedData> T getFeedData(ITailoredFeedInfo<T> feedInfo,
                                     int shift)
                              throws JFException
```
    A type-safe feed data retrieval for the specified feed
    
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedInfo - feed info for corresponding data type
    
    shift - number of bars back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    bar or null if no bar is loaded
    
    Throws:
    
    JFException - when some error occurs when loading data
    
    See Also:
    
    getFeedData(IFeedDescriptor, int)
  - getFeedData
```
java.util.List<ITimedData> getFeedData(IFeedDescriptor feedDescriptor,
                                       long from,
                                       long to)
                                throws JFException
```
    Returns bars for specified feed descriptor. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    
    Parameters:
    
    feedDescriptor - holds parameters: data type, instrument, offer side, etc (depends on bar type), and describes what kind of bars must be loaded
    
    from - start of the time interval for which bars should be loaded
    
    to - end time of the time interval for which bars should be loaded. If there is bar with time equals to the time in to parameter then it will be loaded as well
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getFeedData
```
<T extends ITimedData> java.util.List<T> getFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                                     long from,
                                                     long to)
                                              throws JFException
```
    A type-safe feed data retrieval for the specified feed
    
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor for corresponding data type
    
    from - start of the time interval for which bars should be loaded
    
    to - end time of the time interval for which bars should be loaded. If there is bar with time equals to the time in to parameter then it will be loaded as well
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
    
    See Also:
    
    getFeedData(IFeedDescriptor, long, long)
  - getFeedData
```
java.util.List<ITimedData> getFeedData(IFeedDescriptor feedDescriptor,
                                       int numberOfFeedBarsBefore,
                                       long time,
                                       int numberOfFeedBarsAfter)
                                throws JFException
```
    Returns bars for specified feedDescriptor. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException.
    
    Parameters:
    
    feedDescriptor - holds parameters: data type, instrument, offer side, etc (depends on bar type), and describes what kind of bars must be loaded
    
    numberOfFeedBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - the time of the last bar in period specified in numberOfFeedBarsBefore parameter, or the time of the first bar in period specified with numberOfFeedBarsAfter parameter if numberOfFeedBarsBefore is 0, or the time of the bar prior to the first bar in period specified with numberOfFeedBarsAfter if numberOfFeedBarsBefore is > 0
    
    numberOfFeedBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getFeedData
```
<T extends ITimedData> java.util.List<T> getFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                                     int numberOfFeedBarsBefore,
                                                     long time,
                                                     int numberOfFeedBarsAfter)
                                              throws JFException
```
    A type-safe feed data retrieval for the specified feed
    
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor for corresponding data type
    
    numberOfFeedBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - the time of the last bar in period specified in numberOfFeedBarsBefore parameter, or the time of the first bar in period specified with numberOfFeedBarsAfter parameter if numberOfFeedBarsBefore is 0, or the time of the bar prior to the first bar in period specified with numberOfFeedBarsAfter if numberOfFeedBarsBefore is > 0
    
    numberOfFeedBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when some error occurs when loading data
    
    See Also:
    
    getFeedData(ITailoredFeedDescriptor, int, long, int)
  - readFeedData
```
void readFeedData(IFeedDescriptor feedDescriptor,
                  long from,
                  long to,
                  IFeedListener feedListener,
                  LoadingProgressListener loadingProgress)
           throws JFException
```
    Reads feed data from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, feed data items will be returned by calling method in feedListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last weeks renko bricks - namely calculating the average close price
```
 private IHistory history;
 private IConsole console;

 private Instrument instrument = Instrument.EURUSD;
 private IFeedDescriptor feedDescriptor = new RenkoFeedDescriptor(instrument, PriceRange.TWO_PIPS, OfferSide.ASK);
 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     context.setSubscribedInstruments(Collections.singleton(instrument), true);

     final long to = history.getFeedData(feedDescriptor, 1).getTime();
     final long from = to - Period.DAILY.getInterval() * 7;

     history.readFeedData(
         feedDescriptor,
         from,
         to,
         new IFeedListener() {
              @Override
             public void onFeedData(IFeedDescriptor feedDescriptor, ITimedData feedData) {
                 itemCount++;
                 double price = feedDescriptor.getDataType() == DataType.TICKS
                         ? ((ITick)feedData).getBid()
                         : ((IBar)feedData).getClose();
                 avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double)itemCount));
             }

             private double round(double amount) {
                 return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
             }
         },
         new LoadingProgressListener() {
              @Override
             public void dataLoaded(long start, long end, long currentPosition, String information) {
             }

              @Override
             public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                 console.getOut().format("Loaded %s %s %s  - %s average %s=%.5f    feed descriptor=%s",
                         itemCount,
                         feedDescriptor.getDataType(),
                         DateUtils.format(from),
                         DateUtils.format(to),
                         feedDescriptor.getDataType() == DataType.TICKS ? "bid" : "close",
                         avgPrice,
                         feedDescriptor
                 ).println();
                context.stop();
             }

              @Override
             public boolean stopJob() {
                 return false;
             }
         }
     );
 }
 
```
    Parameters:
    
    feedDescriptor - feed descriptor of the feed data
    
    from - start of the time interval for which feed data items should be loaded.
    
    to - end time of the time interval for which feed data items should be loaded.
    
    feedListener - receives data about requested feed data items
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
  - readFeedData
```
<T extends ITimedData> void readFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                         long from,
                                         long to,
                                         ITailoredFeedListener<T> feedListener,
                                         LoadingProgressListener loadingProgress)
                                  throws JFException
```
    A type-safe feed data retrieval for the specified feed
```
 private IHistory history;
 private IConsole console;

 Instrument instrument = Instrument.EURUSD;
 ITailoredFeedDescriptor <IRenkoBar> feedDescriptor = new RenkoFeedDescriptor(instrument, PriceRange.TWO_PIPS, OfferSide.ASK);
 double avgPrice = 0;
 int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     context.setSubscribedInstruments(Collections.singleton(instrument), true);

     final long to = history.getFeedData(feedDescriptor, 1).getTime();
     final long from = to - Period.DAILY.getInterval() * 7;

     history.readFeedData(
         feedDescriptor,
         from,
         to,
         new ITailoredFeedListener <IRenkoBar>() {
              @Override
             public void onFeedData(ITailoredFeedDescriptor <IRenkoBar> feedDescriptor, IRenkoBar renko) {
                 itemCount++;
                 double price = renko.getClose();
                 avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double)itemCount));
             }

             private double round(double amount) {
                 return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
             }
         },
         new LoadingProgressListener() {
              @Override
             public void dataLoaded(long start, long end, long currentPosition, String information) {
             }

              @Override
             public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                 console.getOut().format("Loaded %s Renkos %s  - %s average close=%.5f    feed descriptor=%s",
                         itemCount,
                         DateUtils.format(from),
                         DateUtils.format(to),
                         avgPrice,
                         feedDescriptor
                 ).println();
                 context.stop();
             }

              @Override
             public boolean stopJob() {
                 return false;
             }
         }
     );
 }
 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor of the feed data
    
    from - start of the time interval for which feed data items should be loaded
    
    to - end time of the time interval for which feed data items should be loaded
    
    feedListener - receives data about requested feed data items
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
    
    See Also:
    
    readFeedData(IFeedDescriptor, long, long, IFeedListener, LoadingProgressListener)
  - readFeedData
```
void readFeedData(IFeedDescriptor feedDescriptor,
                  int numberOfFeedDataBefore,
                  long time,
                  int numberOfFeedDataAfter,
                  IFeedListener feedListener,
                  LoadingProgressListener loadingProgress)
           throws JFException
```
    Reads feed data from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, feed data will be returned by calling method in feedListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of feed data without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last 1000 renko bricks - namely calculating the average close price
```
 private IHistory history;
 private IConsole console;

 private Instrument instrument = Instrument.EURUSD;
 private IFeedDescriptor feedDescriptor = new RenkoFeedDescriptor(Instrument.EURUSD, PriceRange.TWO_PIPS, OfferSide.ASK);
 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     final long to = history.getFeedData(feedDescriptor, 1).getTime();

     history.readFeedData(
         feedDescriptor,
         1000,
         to,
         0,
         new IFeedListener() {
              @Override
             public void onFeedData(IFeedDescriptor feedDescriptor, ITimedData feedData) {
                 itemCount++;
                 double price = feedDescriptor.getDataType() == DataType.TICKS
                       ? ((ITick)feedData).getBid()
                       : ((IBar)feedData).getClose();
                 avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double)itemCount));
             }

             private double round(double amount) {
                 return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
             }
         },
         new LoadingProgressListener() {
              @Override
             public void dataLoaded(long start, long end, long currentPosition, String information) {
             }

              @Override
             public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                 console.getOut().format("Loaded %s %s till %s average %s=%.5f    feed descriptor=%s",
                       itemCount,
                       feedDescriptor.getDataType(),
                       DateUtils.format(to),
                       feedDescriptor.getDataType() == DataType.TICKS ? "bid" : "close",
                       avgPrice,
                       feedDescriptor
                 ).println();
                 context.stop();
             }

              @Override
             public boolean stopJob() {
                 return false;
             }
         }
     );
 }
 
```
    Parameters:
    
    feedDescriptor - feed descriptor of the feed data
    
    numberOfFeedDataBefore - how much feed data items to load before and including feed data item with time specified in time parameter
    
    time - time of the last feed data item in period specified in numberOfFeedDataBefore parameter or/and time of the feed data item prior first feed data item in period specified with numberOfFeedDataAfter parameter
    
    numberOfFeedDataAfter - how much feed data items to load after (not including) feed data item with time specified in time parameter
    
    feedListener - receives feed data
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
  - readFeedData
```
<T extends ITimedData> void readFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                         int numberOfFeedDataBefore,
                                         long time,
                                         int numberOfFeedDataAfter,
                                         ITailoredFeedListener<T> feedListener,
                                         LoadingProgressListener loadingProgress)
                                  throws JFException
```
    A type-safe feed data retrieval for the specified feed
```
 private IHistory history;
 private IConsole console;

 private Instrument instrument = Instrument.EURUSD;
 private ITailoredFeedDescriptor <IRenkoBar> feedDescriptor = new RenkoFeedDescriptor(Instrument.EURUSD, PriceRange.TWO_PIPS, OfferSide.ASK);
 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     final long to = history.getFeedData(feedDescriptor, 1).getTime();

     history.readFeedData(
         feedDescriptor,
         1000,
         to,
         0,
         new ITailoredFeedListener <IRenkoBar>() {
              @Override
             public void onFeedData(ITailoredFeedDescriptor <IRenkoBar> feedDescriptor, IRenkoBar renko) {
                 itemCount++;
                 double price = renko.getClose();
                 avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double)itemCount));
             }
             private double round(double amount) {
                  return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
             }
         },
         new LoadingProgressListener() {
              @Override
             public void dataLoaded(long start, long end, long currentPosition, String information) {
             }

              @Override
             public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                 console.getOut().format("Loaded %s Renkos till %s average close=%.5f feed descriptor=%s",
                         itemCount,
                         DateUtils.format(to),
                         avgPrice,
                         feedDescriptor
                 ).println();
                 context.stop();
             }

              @Override
             public boolean stopJob() {
                 return false;
             }
         }
     );
 }
 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor of the feed data
    
    numberOfFeedDataBefore - how much feed data items to load before and including feed data item with time specified in time parameter
    
    time - time of the last feed data item in period specified in numberOfFeedDataBefore parameter or/and time of the feed data item prior first feed data item in period specified with numberOfFeedDataAfter parameter
    
    numberOfFeedDataAfter - how much feed data items to load after (not including) feed data item with time specified in time parameter
    
    feedListener - receives feed data
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
    
    See Also:
    
    readFeedData(IFeedDescriptor, int, long, int, IFeedListener, LoadingProgressListener)
  - readFeedData
```
<T extends ITimedData> java.util.stream.Stream<T> readFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                                               int numberOfFeedDataBefore,
                                                               long time,
                                                               int numberOfFeedDataAfter,
                                                               LoadingProgressListener loadingProgressListener)
                                                        throws JFException
```
    A type-safe feed data retrieval for the specified feed.
```
 private IHistory history;
 private IConsole console;
 private Instrument instrument = Instrument.EURUSD;

 public void onStart(IContext context) throws JFException {
     this.history = context.getHistory();
     this.console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);

     RenkoFeedDescriptor renkoFeedDescriptor = new RenkoFeedDescriptor(
             instrument,
             PriceRange.TWO_PIPS,
             OfferSide.ASK);

     ITimedData feedData = history.getFeedData(renkoFeedDescriptor, 1);

     double average = history.readFeedData(renkoFeedDescriptor, 10, feedData.getTime(), 0)
             .mapToDouble(renkoBar -> renkoBar.getClose())
             .average()
             .getAsDouble();

     console.getOut().format("Average renko close pirce is %s", average).println();
     context.stop();
 }
 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor of the feed data
    
    numberOfFeedDataBefore - how much feed data items to load before and including feed data item with time specified in time parameter
    
    time - time of the last feed data item in period specified in numberOfFeedDataBefore parameter or/and time of the feed data item prior first feed data item in period specified with numberOfFeedDataAfter parameter
    
    numberOfFeedDataAfter - how much feed data items to load after (not including) feed data item with time specified in time parameter
    
    loadingProgressListener - used to control loading progress
    
    Returns:
    
    stream of loaded bars
    
    Throws:
    
    JFException - when some errors occurs
  - readFeedData
```
<T extends ITimedData> java.util.stream.Stream<T> readFeedData(ITailoredFeedDescriptor<T> feedDescriptor,
                                                               long from,
                                                               long to,
                                                               LoadingProgressListener loadingProgressListener)
                                                        throws JFException
```
    A type-safe feed data retrieval for the specified feed.
```
 private IHistory history;
 private IConsole console;
 private Instrument instrument = Instrument.EURUSD;

 public void onStart(IContext context) throws JFException {
     this.history = context.getHistory();
     this.console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);

     RenkoFeedDescriptor renkoFeedDescriptor = new RenkoFeedDescriptor(
             instrument,
             PriceRange.TWO_PIPS,
             OfferSide.ASK);

     ITimedData feedData10 = history.getFeedData(renkoFeedDescriptor, 10);
     ITimedData feedData1 = history.getFeedData(renkoFeedDescriptor, 1);

     LoadingProgressListener loadingProgressListener = new LoadingProgressListener() {

         @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

         @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
         }

         @Override
         public boolean stopJob() {
             return false;
         }
     };

     double average = history.readFeedData(
             renkoFeedDescriptor, feedData10.getTime(), feedData1.getTime(), loadingProgressListener)
             .mapToDouble(renkoBar -> renkoBar.getClose())
             .average()
             .getAsDouble();

     console.getOut().format("Average renko close pirce is %s", average).println();
     context.stop();
 }
 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedDescriptor - feed descriptor of the feed data
    
    from - start of the time interval for which feed data items should be loaded
    
    to - end time of the time interval for which feed data items should be loaded
    
    loadingProgressListener - used to control loading progress
    
    Returns:
    
    stream of loaded bars
    
    Throws:
    
    JFException - when some errors occurs
  - readTicks
```
@Deprecated
void readTicks(IFinancialInstrument financialInstrument,
                           int numberOfOneSecondIntervalsBefore,
                           long time,
                           int numberOfOneSecondIntervalsAfter,
                           LoadingDataListener tickListener,
                           LoadingProgressListener loadingProgress)
                    throws JFException
```
    Deprecated.
    
    Reads ticks from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, ticks will be returned by calling method in tickListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of ticks without keeping them all in memory, and second is asynchronous processing
    
    Parameters:
    
    financialInstrument - financial instrument of the ticks
    
    numberOfOneSecondIntervalsBefore - how much one second interval of ticks to load before and including one second interval of ticks with time specified in time parameter
    
    time - time of the last one second tick interval in period specified in numberOfOneSecondIntervalsBefore parameter or/and time of the one second tick interval prior first one second tick interval in period specified with numberOfOneSecondIntervalsAfter parameter
    
    numberOfOneSecondIntervalsAfter - how much one second tick intervals to load after (not including) one second tick interval with time specified in time parameter
    
    tickListener - receives data about requested ticks
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
  - getBars
```
@Deprecated
java.util.List<IBar> getBars(IFinancialInstrument financialInstrument,
                                         Period period,
                                         OfferSide side,
                                         Filter filter,
                                         long from,
                                         long to)
                                  throws JFException
```
    Deprecated.
    
    Returns bars for specified instrument, period, side and filter. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    
    Parameters:
    
    financialInstrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - bars filtering method see Filter
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for candle that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last candle to be loaded
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when period is not supported or some error occurs when loading data
  - getFeedData
```
@Deprecated
java.util.List<ITimedData> getFeedData(IFeedInfo feedInfo,
                                                   long from,
                                                   long to)
                                            throws JFException
```
    Deprecated.
    
    Returns bars for specified feed info. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    
    Parameters:
    
    feedInfo - holds parameters: data type, financial instrument, offer side, etc (depends on bar type), and describes what kind of bars must be loaded
    
    from - start of the time interval for which bars should be loaded
    
    to - end time of the time interval for which bars should be loaded. If there is bar with time equals to the time in to parameter then it will be loaded as well
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getFeedData
```
@Deprecated
<T extends ITimedData> java.util.List<T> getFeedData(ITailoredFeedInfo<T> feedInfo,
                                                                 long from,
                                                                 long to)
                                                          throws JFException
```
    Deprecated.
    
    A type-safe feed data retrieval for the specified feed
    
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedInfo - feed info for corresponding data type
    
    from - start of the time interval for which bars should be loaded
    
    to - end time of the time interval for which bars should be loaded. If there is bar with time equals to the time in to parameter then it will be loaded as well
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
    
    See Also:
    
    getFeedData(IFeedInfo, long, long)
  - getTimeOfLastTick
```
@Deprecated
long getTimeOfLastTick(IFinancialInstrument financialInstrument)
                            throws JFException
```
    Deprecated.
    
    Returns time of last tick received for specified instrument. Returns -1 if no tick was received yet.
    
    Parameters:
    
    financialInstrument - instrument of the tick
    
    Returns:
    
    time of last tick or -1 if no tick was received
    
    Throws:
    
    JFException - when instrument is not active (not opened in platform)
  - getLastTick
```
@Deprecated
ITick getLastTick(IFinancialInstrument financialInstrument)
                       throws JFException
```
    Deprecated.
    
    Returns last tick for specified instrument
    
    Parameters:
    
    financialInstrument - instrument of the tick
    
    Returns:
    
    tick
    
    Throws:
    
    JFException - when instrument is not active (not opened in platform)
  - getStartTimeOfCurrentBar
```
@Deprecated
long getStartTimeOfCurrentBar(IFinancialInstrument financialInstrument,
                                          Period period)
                                   throws JFException
```
    Deprecated.
    
    Returns starting time of the current bar (bar currently generated from ticks) for specified instrument and period. If no tick was received for this instrument, then returns -1.
    
    Parameters:
    
    financialInstrument - instrument of the bar
    
    period - period of the bar
    
    Returns:
    
    starting time of the current bar or -1 if no tick was received
    
    Throws:
    
    JFException - when period is not supported or instrument is not active (not opened in platform)
  - getBar
```
@Deprecated
IBar getBar(IFinancialInstrument financialInstrument,
                        Period period,
                        OfferSide side,
                        int shift)
                 throws JFException
```
    Deprecated.
    Returns bar for specified instrument, period and side, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar (currently generated from ticks), 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null.
    consider getting the previous one hour bar
```
 private IHistory history;
 private IConsole console;

 Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     IBar prevBar = history.getBar(financialInstrument, Period.ONE_HOUR, OfferSide.BID, 1);
     console.getOut().println(prevBar);
 }
 
```
    Parameters:
    
    financialInstrument - instrument of the bar
    
    period - period of the bar
    
    side - bid or ask side of the bar
    
    shift - number of candle back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    bar or null if no bar is loaded
    
    Throws:
    
    JFException - when period is not supported or instrument is not active (not opened in platform)
  - readTicks
```
@Deprecated
void readTicks(IFinancialInstrument financialInstrument,
                           long from,
                           long to,
                           DataLoadingListener tickListener,
                           LoadingProgressListener loadingProgress)
                    throws JFException
```
    Deprecated.
    Reads ticks from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, ticks will be returned by calling methods in tickListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error. This method has two main purposes: one is to load a lot of ticks without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last days ticks - namely calculating the average ask price and the maximum bid
```
     private IHistory history;
     private IConsole console;

     double maxBid = Double.MIN_VALUE;
     double avgAsk = 0;
     int tickCount = 0;

      @Override
     public void onStart(final IContext context) throws JFException {
         history = context.getHistory();
         console = context.getConsole();
         IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
         final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

         context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
         final long from = history.getLastTick(financialInstrument).getTime() - Period.DAILY.getInterval();
         final long to = history.getLastTick(financialInstrument).getTime();

         history.readTicks(financialInstrument, from, to,
             new LoadingFinancialDataListener() {
                  @Override
                 public void newTick(IFinancialInstrument financialInstrument, long time, double ask, double bid, double askVol, double bidVol) {
                     tickCount++;
                     maxBid = Math.max(bid, maxBid);
                     avgAsk = tickCount == 1 ? ask : round(avgAsk + ((avgAsk - ask) / (double)tickCount));
                 }

                 private double round(double amount) {
                     return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale(), BigDecimal.ROUND_HALF_UP).doubleValue();
                 }

                  @Override
                 public void newBar(IFinancialInstrument financialInstrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
                     // no bars expected
                 }
             },

             new LoadingProgressListener() {

                  @Override
                 public void dataLoaded(long start, long end, long currentPosition, String information) {

                 }

                  @Override
                 public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                     console.getOut().format("Loaded %s ticks %s - %s max Bid=%.5f average ask=%.5f",
                     tickCount, DateUtils.format(from), DateUtils.format(to), maxBid, avgAsk).println();
                     context.stop();
                 }

                  @Override
                 public boolean stopJob() {
                     return false;
                 }
             });
         }
 
```
    Parameters:
    
    financialInstrument - instrument of the ticks
    
    from - start of the time interval for which ticks should be loaded
    
    to - end time of the time interval for which ticks should be loaded. If there is tick with time equals to the time in to parameter then it will be loaded as well
    
    tickListener - receives data about requested ticks
    
    loadingProgress - used to control loading process
    
    Throws:
    
    JFException - when some error occurs while creating internal request for data
  - readBars
```
@Deprecated
void readBars(IFinancialInstrument financialInstrument,
                          Period period,
                          OfferSide side,
                          long from,
                          long to,
                          DataLoadingListener barListener,
                          LoadingProgressListener loadingProgress)
                   throws JFException
```
    Deprecated.
    Reads bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in barListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last weeks 1 minute bars - namely calculating the average close price and the maximum bar size
```
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;

 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
     long lastTickTime = history.getLastTick(financialInstrument).getTime();
     final long from = history.getBarStart(period, lastTickTime - Period.DAILY.getInterval() * 7);
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(financialInstrument, period, OfferSide.BID, from, to,

         new LoadingFinancialDataListener() {
              @Override
             public void newTick(IFinancialInstrument financialInstrument, long time, double ask, double bid, double askVol, double bidVol) {}

              @Override
             public void newBar(IFinancialInstrument financialInstrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
                 barCount++;
                 maxHeight = Math.max(Math.abs(open - close), maxHeight);
                 avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
                 if(close - open > 0){
                     greenCount++;
                 }
             }

             private double round(double amount) {
                 return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
             }
         },
         new LoadingProgressListener() {

              @Override
             public void dataLoaded(long start, long end, long currentPosition, String information) {
             }

              @Override
             public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                 console.getOut().format("Loaded %s %s candles (%s green, %s red) %s  - %s max bar height=%.1fpips average close=%.5f",
                         barCount, period, greenCount, barCount - greenCount, DateUtils.format(from), DateUtils.format(to), maxHeight/financialInstrument.getPipValue(), avgClose).println();
                 context.stop();
             }

              @Override
             public boolean stopJob() {
                 return false;
             }
         });
 }
 
```
    Parameters:
    
    financialInstrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for bar that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last bar to be loaded
    
    barListener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when period is not supported or time interval is not valid for specified period
    
    See Also:
    
    getBarStart(Period, long)
  - readBars
```
@Deprecated
void readBars(IFinancialInstrument financialInstrument,
                          Period period,
                          OfferSide side,
                          Filter filter,
                          long from,
                          long to,
                          DataLoadingListener barListener,
                          LoadingProgressListener loadingProgress)
                   throws JFException
```
    Deprecated.
    Reads bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in barListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last weeks 1 minute bars - namely calculating the average close price and the maximum bar size
```
 int barCount = 0;
 int greenCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
         history = context.getHistory();
         console = context.getConsole();
         IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
         final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

         context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
         long lastTickTime = history.getLastTick(financialInstrument).getTime();
         final long from = history.getBarStart(period, lastTickTime - Period.DAILY.getInterval() * 7);
         final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

         history.readBars(financialInstrument, period, OfferSide.BID, Filter.WEEKENDS, from, to,

                 new LoadingFinancialDataListener() {
                          @Override
                         public void newTick(IFinancialInstrument financialInstrument, long time, double ask, double bid, double askVol, double bidVol) {}

                          @Override
                         public void newBar(IFinancialInstrument financialInstrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
                                 barCount++;
                                 maxHeight = Math.max(Math.abs(open - close), maxHeight);
                                 avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
                                 if(close - open > 0){
                                        greenCount++;
                                }
                         }

                         private double round(double amount) {
                                return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
                         }
                 },
                 new LoadingProgressListener() {

                          @Override
                         public void dataLoaded(long start, long end, long currentPosition, String information) {
                         }

                          @Override
                         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
                                 console.getOut().format("Loaded %s %s candles (%s green, %s red) %s  - %s max bar height=%.1fpips average close=%.5f",
                                 barCount, period, greenCount, barCount - greenCount, DateUtils.format(from), DateUtils.format(to), maxHeight/financialInstrument.getPipValue(), avgClose).println();
                                 context.stop();
                         }

                          @Override
                         public boolean stopJob() {
                                 return false;
                         }
                 }
         );
 }
 
```
    Parameters:
    
    financialInstrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - bars filtering method see Filter
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for bar that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last bar to be loaded
    
    barListener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when period is not supported or time interval is not valid for specified period
    
    See Also:
    
    getBarStart(Period, long)
  - readBars
```
@Deprecated
void readBars(IFinancialInstrument financialInstrument,
                          Period period,
                          OfferSide side,
                          Filter filter,
                          int numberOfCandlesBefore,
                          long time,
                          int numberOfCandlesAfter,
                          DataLoadingListener barListener,
                          LoadingProgressListener loadingProgress)
                   throws JFException
```
    Deprecated.
    Reads bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in barListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the 100000 1 minute bars - namely calculating the average close price and the maximum bar size
```
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;
 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
     long lastTickTime = history.getLastTick(financialInstrument).getTime();
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(financialInstrument, period, OfferSide.BID, Filter.WEEKENDS, 100000, to, 0,

     new LoadingFinancialDataListener() {
          @Override
         public void newTick(IFinancialInstrument financialInstrument, long time, double ask, double bid, double askVol, double bidVol) {}

          @Override
         public void newBar(IFinancialInstrument financialInstrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             barCount++;
             maxHeight = Math.max(Math.abs(open - close), maxHeight);
             avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
             if(close - open > 0){
                 greenCount++;
             }
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s %s candles (%s green, %s red) till %s max bar height=%.1fpips average close=%.5f",
                     barCount, period, greenCount, barCount - greenCount, DateUtils.format(to), maxHeight/financialInstrument.getPipValue(), avgClose).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     });
 }
 
```
    Parameters:
    
    financialInstrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - allows to filter candles
    
    numberOfCandlesBefore - how much candles to load before and including candle with time specified in time parameter
    
    time - time of the last candles in period specified in numberOfCandlesBefore parameter or/and time of the candle prior first candle in period specified with numberOfCandlesAfter parameter
    
    numberOfCandlesAfter - how much candles to load after (not including) candle with time specified in time parameter
    
    barListener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when period is not supported or time interval is not valid for specified period
    
    See Also:
    
    getBarStart(Period, long)
  - getTicks
```
@Deprecated
java.util.List<ITick> getTicks(IFinancialInstrument financialInstrument,
                                           long from,
                                           long to)
                                    throws JFException
```
    Deprecated.
    Returns ticks for specified instrument and time interval. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
```
  @Override
 public void onStart(final IContext context) throws JFException {
     this.history = context.getHistory();
     this.console = context.getConsole();

     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     ITick lastTick = history.getLastTick(financialInstrument);
     List <ITick> = history.getTicks(financialInstrument, lastTick.getTime() - 10 * 1000, lastTick.getTime());
     int last = ticks.size() - 1;
     console.getOut().format("Tick count=%s; Latest bid price=%.5f, time=%s; Oldest bid price=%.5f, time=%s",
         ticks.size(), ticks.get(last).getBid(), DateUtils.format(ticks.get(last).getTime()), ticks.get(0).getBid(), DateUtils.format(ticks.get(last).getTime()) ).println();
 }
 
```
    Parameters:
    
    financialInstrument - instrument of the ticks
    
    from - start of the time interval for which ticks should be loaded
    
    to - end time of the time interval for which ticks should be loaded. If there is tick with time equals to the time in to parameter then it will be loaded as well
    
    Returns:
    
    loaded ticks
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getTicks
```
@Deprecated
java.util.List<ITick> getTicks(IFinancialInstrument financialInstrument,
                                           int numberOfOneSecondIntervalsBefore,
                                           long time,
                                           int numberOfOneSecondIntervalsAfter)
                                    throws JFException
```
    Deprecated.
    
    Returns ticks for specified instrument, time and count. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    
    Parameters:
    
    financialInstrument - instrument of the ticks
    
    numberOfOneSecondIntervalsBefore - how much one second interval of ticks to load before and including one second interval of ticks with time specified in time parameter
    
    time - time of the last one second tick interval in period specified in numberOfOneSecondIntervalsBefore parameter or/and time of the one second tick interval prior first one second tick interval in period specified with numberOfOneSecondIntervalsAfter parameter
    
    numberOfOneSecondIntervalsAfter - how much one second tick intervals to load after (not including) one second tick interval with time specified in time parameter
    
    Returns:
    
    loaded ticks
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getBars
```
@Deprecated
java.util.List<IBar> getBars(IFinancialInstrument financialInstrument,
                                         Period period,
                                         OfferSide side,
                                         long from,
                                         long to)
                                  throws JFException
```
    Deprecated.
    Returns bars for specified instrument, period and side. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException
    Consider getting 5 bars over a time interval:
```
 private IHistory history;
 private IConsole console;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

     long prevBarTime = history.getPreviousBarStart(Period.ONE_HOUR, history.getLastTick(financialInstrument).getTime());
     long startTime =  history.getTimeForNBarsBack(Period.ONE_HOUR, prevBarTime, 5);
     List <IBar> bars = history.getBars(financialInstrument, Period.ONE_HOUR, OfferSide.BID, startTime, prevBarTime);
     int last = bars.size() - 1;
     console.getOut().format(
         "Previous bar close price=%.5f; 4th to previous bar close price=%.5f",
             bars.get(last).getClose(), bars.get(0).getClose()
     ).println();
 }

 
```
    Parameters:
    
    financialInstrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    from - start of the time interval for which bars should be loaded. Should be the exact starting time of the bar for specified period. See getBarStart(Period, long) description if you want to get bar starting time for candle that includes specific time
    
    to - end time of the time interval for which bars should be loaded. This is the starting time of the last candle to be loaded
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when period is not supported or some error occurs when loading data
  - getBars
```
@Deprecated
java.util.List<IBar> getBars(IFinancialInstrument financialInstrument,
                                         Period period,
                                         OfferSide side,
                                         Filter filter,
                                         int numberOfCandlesBefore,
                                         long time,
                                         int numberOfCandlesAfter)
                                  throws JFException
```
    Deprecated.
    Returns bars for specified instrument, period and side. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException. If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included even if it's flat
    Consider getting 5 bars over a candle interval:
```
 private IHistory history;
 private IConsole console;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();

     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);

     long prevBarTime = history.getPreviousBarStart(Period.ONE_HOUR, history.getLastTick(financialInstrument).getTime());
     List <IBar> bars = history.getBars(financialInstrument, Period.ONE_HOUR, OfferSide.BID, Filter.NO_FILTER, 5, prevBarTime, 0);
     int last = bars.size() - 1;
     console.getOut().format(
         "Previous bar close price=%.5f; 4th to previous bar close price=%.5f",
         bars.get(last).getClose(), bars.get(0).getClose()).println();
 }
 
```
    Parameters:
    
    financialInstrument - instrument of the bars
    
    period - period of the bars
    
    side - side of the bars
    
    filter - allows to filter candles
    
    numberOfCandlesBefore - how much candles to load before and including candle with time specified in time parameter
    
    time - time of the last candle in period specified in numberOfCandlesBefore parameter, or time of the first candle in period specified with numberOfCandlesAfter parameter if numberOfCandlesBefore is 0, or time of the candle prior to first candle in period specified with numberOfCandlesAfter if numberOfCandlesBefore is > 0
    
    numberOfCandlesAfter - how much candles to load after (not including) candle with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when period is not supported or some error occurs when loading data
  - readOrdersHistory
```
@Deprecated
void readOrdersHistory(IFinancialInstrument financialInstrument,
                                   long from,
                                   long to,
                                   OrdersLoadingListener ordersListener,
                                   LoadingProgressListener loadingProgress)
                            throws JFException
```
    Deprecated.
    
    Loads orders from the server in the background. Method returns fast after creating request for data not waiting for any data to be loaded After internal request is sent, orders will be returned by calling method in ordersListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method can be used for orders loading without blocking strategy execution NB! Only one order history request can be sent at a time. If there is another request sent method will throw JFException
    
    Parameters:
    
    financialInstrument - instrument of the orders
    
    from - start of the time interval for which orders should be loaded
    
    to - end time of the time interval for which orders should be loaded
    
    ordersListener - receives data about requested orders
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - in case of any system error
    
    See Also:
    
    getOrdersHistory(IFinancialInstrument financialInstrument, long from, long to)
  - getOrdersHistory
```
@Deprecated
java.util.List<IOrder> getOrdersHistory(IFinancialInstrument financialInstrument,
                                                    long from,
                                                    long to)
                                             throws JFException
```
    Deprecated.
    
    Returns orders for specified instrument and time interval. Method blocks until all data will be loaded from the server. NB! Only one order history request can be sent at a time. If there is another request sent method will throw JFException
    
    Parameters:
    
    financialInstrument - instrument of the orders
    
    from - start of the time interval for which orders should be loaded
    
    to - end time of the time interval for which orders should be loaded
    
    Returns:
    
    loaded orders
    
    Throws:
    
    JFException - in case of any system error
  - getOpenOrders
```
@Deprecated
java.util.List<IOrder> getOpenOrders(IFinancialInstrument financialInstrument,
                                                 long from,
                                                 long to)
```
    Deprecated.
    
    Returns open orders for specified instrument and time interval.
    
    Parameters:
    
    financialInstrument - instrument of the orders
    
    from - start of the time interval for which orders should be loaded
    
    to - end time of the time interval for which orders should be loaded
    
    Returns:
    
    open orders
  - getTick
```
@Deprecated
ITick getTick(IFinancialInstrument financialInstrument,
                          int shift)
                   throws JFException
```
    Deprecated.
    Returns tick for specified instrument, that is shifted back in time for number in ticks specified in shift parameter, 0 - current tick, 1 - previous tick.
```
 IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
 final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
 ITick tick0 = history.getTick(financialInstrument, 0);
 ITick tick1 = history.getTick(financialInstrument, 1);
 console.getOut().format("last tick: %s; previous tick: %s", tick0, tick1).println();
 
```
    Parameters:
    
    financialInstrument - instrument of the tick
    
    shift - number of tick back in time staring from current tick. 1 - previous tick, 2 - current tick minus 2 ticks and so on
    
    Returns:
    
    tick
    
    Throws:
    
    JFException - when instrument is not active (not opened in platform) or other errors
  - getFeedData
```
@Deprecated
ITimedData getFeedData(IFeedInfo feedInfo,
                                   int shift)
                            throws JFException
```
    Deprecated.
    
    Returns bar for specified feed info, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar (currently generated), 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null.
    
    Parameters:
    
    feedInfo - holds parameters: data type, financial instrument, offer side, etc (depends on bar type), and describes what kind of bars must be loaded
    
    shift - number of bars back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    bar or null if no bar is loaded, the type of returning bar depends on IFeedInfo.getDataType()
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getFeedData
```
@Deprecated
java.util.List<ITimedData> getFeedData(IFeedInfo feedInfo,
                                                   int numberOfFeedBarsBefore,
                                                   long time,
                                                   int numberOfFeedBarsAfter)
                                            throws JFException
```
    Deprecated.
    
    Returns bars for specified feedInfo. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException.
    
    Parameters:
    
    feedInfo - holds parameters: data type, financial instrument, offer side, etc (depends on bar type), and describes what kind of bars must be loaded
    
    numberOfFeedBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - the time of the last bar in period specified in numberOfFeedBarsBefore parameter, or the time of the first bar in period specified with numberOfFeedBarsAfter parameter if numberOfFeedBarsBefore is 0, or the time of the bar prior to the first bar in period specified with numberOfFeedBarsAfter if numberOfFeedBarsBefore is > 0
    
    numberOfFeedBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when some error occurs when loading data
  - getFeedData
```
@Deprecated
<T extends ITimedData> java.util.List<T> getFeedData(ITailoredFeedInfo<T> feedInfo,
                                                                 int numberOfFeedBarsBefore,
                                                                 long time,
                                                                 int numberOfFeedBarsAfter)
                                                          throws JFException
```
    Deprecated.
    
    A type-safe feed data retrieval for the specified feed
    
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedInfo - feed info for corresponding data type
    
    numberOfFeedBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - the time of the last bar in period specified in numberOfFeedBarsBefore parameter, or the time of the first bar in period specified with numberOfFeedBarsAfter parameter if numberOfFeedBarsBefore is 0, or the time of the bar prior to the first bar in period specified with numberOfFeedBarsAfter if numberOfFeedBarsBefore is > 0
    
    numberOfFeedBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when some error occurs when loading data
    
    See Also:
    
    getFeedData(IFeedInfo, int, long, int)
  - readFeedData
```
@Deprecated
void readFeedData(IFeedInfo feedInfo,
                              long from,
                              long to,
                              IFinancialFeedListener feedListener,
                              LoadingProgressListener loadingProgress)
                       throws JFException
```
    Deprecated.
    Reads feed data from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, feed data items will be returned by calling method in feedListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last weeks renko bricks - namely calculating the average close price
```
 private IHistory history;
 private IConsole console;

 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider financialInstrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = financialInstrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
     final IFeedInfo feedInfo = new RenkoFeedInfo(financialInstrument, PriceRange.TWO_PIPS, OfferSide.ASK, Period.ONE_HOUR, CreationPoint.OPEN);

     final long from = history.getFeedData(feedInfo, 10).getTime();
     final long to = history.getFeedData(feedInfo, 1).getTime();

     IFinancialFeedListener tailoredFinancialFeedListener = new IFinancialFeedListener() {
          @Override
         public void onFeedData(IFeedInfo feedInfo, ITimedData feedData) {
             itemCount++;

             double price = ((IRenkoBar) feedData).getClose();
             avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double) itemCount));
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     };

     LoadingProgressListener loadingProgressListener = new LoadingProgressListener() {
          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s Renkos till %s average close=%.5f feed descriptor=%s",
                     itemCount,
                     DateUtils.format(to),
                     avgPrice,
                     feedInfo
             ).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     };

     history.readFeedData(
             feedInfo,
             from,
             to,
             tailoredFinancialFeedListener,
             loadingProgressListener
     );
 }

 
```
    Parameters:
    
    feedInfo - feed info of the feed data
    
    from - start of the time interval for which feed data items should be loaded.
    
    to - end time of the time interval for which feed data items should be loaded.
    
    feedListener - receives data about requested feed data items
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
  - readFeedData
```
@Deprecated
<T extends ITimedData> void readFeedData(ITailoredFeedInfo<T> feedInfo,
                                                     long from,
                                                     long to,
                                                     ITailoredFinancialFeedListener<T> tailoredFinancialFeedListener,
                                                     LoadingProgressListener loadingProgress)
                                              throws JFException
```
    Deprecated.
    A type-safe feed data retrieval for the specified feed
```
 private IHistory history;
 private IConsole console;

 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider financialInstrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = financialInstrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
     final ITailoredFeedInfo <IRenkoBar> tailoredFeedInfo = new RenkoFeedInfo(financialInstrument, PriceRange.TWO_PIPS, OfferSide.ASK, Period.ONE_HOUR, CreationPoint.OPEN);

     final long from = history.getFeedData(tailoredFeedInfo, 10).getTime();
     final long to = history.getFeedData(tailoredFeedInfo, 1).getTime();

     ITailoredFinancialFeedListener <IRenkoBar> tailoredFinancialFeedListener = new ITailoredFinancialFeedListener <IRenkoBar>() {
          @Override
         public void onFeedData(ITailoredFeedInfo <IRenkoBar> tailoredFeedInfo, IRenkoBar renko) {
             itemCount++;

             double price = renko.getClose();
             avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double) itemCount));
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     };

     LoadingProgressListener loadingProgressListener = new LoadingProgressListener() {
          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s Renkos till %s average close=%.5f feed descriptor=%s",
                     itemCount,
                     DateUtils.format(to),
                     avgPrice,
                     tailoredFeedInfo
             ).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     };

     history.readFeedData(
             tailoredFeedInfo,
             from,
             to,
             tailoredFinancialFeedListener,
             loadingProgressListener
     );
 }
 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedInfo - feed info for corresponding data type
    
    from - start of the time interval for which feed data items should be loaded.
    
    to - end time of the time interval for which feed data items should be loaded.
    
    tailoredFinancialFeedListener - receives data about requested feed data items
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
    
    See Also:
    
    readFeedData(IFeedDescriptor, long, long, IFeedListener, LoadingProgressListener)
  - readFeedData
```
@Deprecated
<T extends ITimedData> void readFeedData(IFeedInfo feedInfo,
                                                     int numberOfFeedDataBefore,
                                                     long time,
                                                     int numberOfFeedDataAfter,
                                                     IFinancialFeedListener financialFeedListener,
                                                     LoadingProgressListener loadingProgress)
                                              throws JFException
```
    Deprecated.
    Reads feed data from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, feed data will be returned by calling method in feedListener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of feed data without keeping them all in memory, and second is asynchronous processing
    Consider analyzing the last 1000 renko bricks - namely calculating the average close price
```
 private IHistory history;
 private IConsole console;

 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider financialInstrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = financialInstrumentProvider.getFinancialInstrument("EUR/USD");
     final IFeedInfo feedInfo = new RenkoFeedInfo(financialInstrument, PriceRange.TWO_PIPS, OfferSide.ASK);

     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);

     final long time = history.getFeedData(feedInfo, 1).getTime();

     IFinancialFeedListener financialFeedListener = new IFinancialFeedListener() {
          @Override
         public void onFeedData(IFeedInfo feedInfo, ITimedData feedData) {
             itemCount++;
             double price = ((IRenkoBar) feedData).getClose();
             avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double) itemCount));
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     };

     LoadingProgressListener loadingProgressListener = new LoadingProgressListener() {
          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s Renkos till %s average close=%.5f feed descriptor=%s",
                     itemCount,
                     DateUtils.format(time),
                     avgPrice,
                     feedInfo
             ).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     };

     history.readFeedData(
             feedInfo,
             1000,
             time,
             0,
             financialFeedListener,
             loadingProgressListener
     );
 }

 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedInfo - feed info of the feed data
    
    numberOfFeedDataBefore - how much feed data items to load before and including feed data item with time specified in time parameter
    
    time - time of the last feed data item in period specified in numberOfFeedDataBefore parameter or/and time of the feed data item prior first feed data item in period specified with numberOfFeedDataAfter parameter
    
    numberOfFeedDataAfter - how much feed data items to load after (not including) feed data item with time specified in time parameter
    
    financialFeedListener - receives feed data
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
  - readFeedData
```
@Deprecated
<T extends ITimedData> void readFeedData(ITailoredFeedInfo<T> feedInfo,
                                                     int numberOfFeedDataBefore,
                                                     long time,
                                                     int numberOfFeedDataAfter,
                                                     ITailoredFinancialFeedListener<T> tailoredFinancialFeedListener,
                                                     LoadingProgressListener loadingProgress)
                                              throws JFException
```
    Deprecated.
    A type-safe feed data retrieval for the specified feed
```
 private IHistory history;
 private IConsole console;

 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider financialInstrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = financialInstrumentProvider.getFinancialInstrument("EUR/USD");
     final ITailoredFeedInfo <IRenkoBar> tailoredFeedInfo = new RenkoFeedInfo(financialInstrument, PriceRange.TWO_PIPS, OfferSide.ASK);

     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);

     final long time = history.getFeedData(tailoredFeedInfo, 1).getTime();

     ITailoredFinancialFeedListener <IRenkoBar> tailoredFinancialFeedListener = new ITailoredFinancialFeedListener <IRenkoBar>() {
          @Override
         public void onFeedData(ITailoredFeedInfo <IRenkoBar> tailoredFeedInfo, IRenkoBar renko) {
             itemCount++;
             double price = renko.getClose();
             avgPrice = itemCount == 1 ? price : round(avgPrice + ((price - avgPrice) / (double) itemCount));
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     };

     LoadingProgressListener loadingProgressListener = new LoadingProgressListener() {
          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s Renkos till %s average close=%.5f feed descriptor=%s",
                     itemCount,
                     DateUtils.format(time),
                     avgPrice,
                     tailoredFeedInfo
             ).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     };

     history.readFeedData(
             tailoredFeedInfo,
             1000,
             time,
             0,
             tailoredFinancialFeedListener,
             loadingProgressListener
     );
 }

 
```
    Type Parameters:
    
    T - type of data feed element
    
    Parameters:
    
    feedInfo - feed info for corresponding data type
    
    numberOfFeedDataBefore - how much feed data items to load before and including feed data item with time specified in time parameter
    
    time - time of the last feed data item in period specified in numberOfFeedDataBefore parameter or/and time of the feed data item prior first feed data item in period specified with numberOfFeedDataAfter parameter
    
    numberOfFeedDataAfter - how much feed data items to load after (not including) feed data item with time specified in time parameter
    
    tailoredFinancialFeedListener - receives feed data
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when some errors occurs
    
    See Also:
    
    readFeedData(IFeedInfo, int, long, int, IFinancialFeedListener, LoadingProgressListener)
  - getPointAndFigure
```
@Deprecated
IPointAndFigure getPointAndFigure(Instrument instrument,
                                              OfferSide offerSide,
                                              PriceRange boxSize,
                                              ReversalAmount reversalAmount,
                                              int shift)
                                       throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int).
    
    Returns Point and Figure for specified instrument, offer side, box size and reversal amount, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar, 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT). To indicate specific base period and/or data interpolation descriptor, use getFeedData(ITailoredFeedDescriptor, int).
    
    Parameters:
    
    instrument - instrument of P&F
    
    offerSide - bid or ask side of P&F
    
    boxSize - box size of the P&F
    
    reversalAmount - reversal amount of the P&F
    
    shift - number of P&F back in time staring from current P&F. 1 - previous P&F, 2 - current P&F minus 2 bars and so on
    
    Returns:
    
    P&F or null if no P&F is loaded
    
    Throws:
    
    JFException - when shift value is negative or instrument is not active (not opened in platform)
  - getPointAndFigures
```
@Deprecated
java.util.List<IPointAndFigure> getPointAndFigures(Instrument instrument,
                                                               OfferSide offerSide,
                                                               PriceRange boxSize,
                                                               ReversalAmount reversalAmount,
                                                               long from,
                                                               long to)
                                                        throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, long, long).
    
    Returns Point and Figures for specified instrument, offer side, box size and reversal amount. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT). To indicate specific base period and/or data interpolation descriptor, use getFeedData(ITailoredFeedDescriptor, long, long). Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too Subscribe to Point and Figure live notification first, before call this method.
    
    Parameters:
    
    instrument - of P&Fs
    
    offerSide - offer side of P&Fs
    
    boxSize - box size of P&Fs
    
    reversalAmount - reversal amount of P&Fs
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    Returns:
    
    loaded Point And Figures
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getPointAndFigures
```
@Deprecated
java.util.List<IPointAndFigure> getPointAndFigures(Instrument instrument,
                                                               OfferSide offerSide,
                                                               PriceRange boxSize,
                                                               ReversalAmount reversalAmount,
                                                               int numberOfBarsBefore,
                                                               long time,
                                                               int numberOfBarsAfter)
                                                        throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int, long, int).
    
    Returns Point and Figures for specified instrument, offer side, box size and reversal amount. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT). To indicate specific base period and/or data interpolation descriptor, use getFeedData(ITailoredFeedDescriptor, int, long, int). Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException. If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too Subscribe to Point and Figure live notification first, before call this method.
    
    Parameters:
    
    instrument - instrument of the P&Fs
    
    offerSide - offer side of the P&Fs
    
    boxSize - price range of the P&Fs
    
    reversalAmount - reversal amount of P&Fs
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when desired data amount is negative, etc; or some error occurs when loading data
  - readPointAndFigures
```
@Deprecated
void readPointAndFigures(Instrument instrument,
                                     OfferSide offerSide,
                                     PriceRange boxSize,
                                     ReversalAmount reversalAmount,
                                     long from,
                                     long to,
                                     IPointAndFigureFeedListener listener,
                                     LoadingProgressListener loadingProgress)
                              throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Point and Figures from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT).
    Subscribe to Point and Figure live notification first, before call this method.
    
    Parameters:
    
    instrument - of P&Fs
    
    offerSide - offer side of P&Fs
    
    boxSize - box size of P&Fs
    
    reversalAmount - reversal amount of P&Fs
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - readPointAndFigures
```
@Deprecated
void readPointAndFigures(Instrument instrument,
                                     OfferSide offerSide,
                                     PriceRange boxSize,
                                     ReversalAmount reversalAmount,
                                     int numberOfBarsBefore,
                                     long time,
                                     int numberOfBarsAfter,
                                     IPointAndFigureFeedListener listener,
                                     LoadingProgressListener loadingProgress)
                              throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Point and Figures from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT).
    Subscribe to Point and Figure live notification first, before call this method.
    
    Parameters:
    
    instrument - of P&Fs
    
    offerSide - offer side of P&Fs
    
    boxSize - box size of P&Fs
    
    reversalAmount - reversal amount of P&Fs
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getTickBar
```
@Deprecated
ITickBar getTickBar(Instrument instrument,
                                OfferSide offerSide,
                                TickBarSize tickBarSize,
                                int shift)
                         throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int).
    
    Returns tick bar for specified instrument, offer side and tick bar size, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar, 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone. To indicate specific base period, use getFeedData(ITailoredFeedDescriptor, int).
    
    Parameters:
    
    instrument - instrument of the tick bar
    
    offerSide - bid or ask side of the tick bar
    
    tickBarSize - tick bar size of the tick bar
    
    shift - number of tick bar back in time staring from current tick bar. 1 - previous tick bar, 2 - current tick bar minus 2 bars and so on
    
    Returns:
    
    range bar or null if no bar is loaded
    
    Throws:
    
    JFException - when shift value is negative or instrument is not active (not opened in platform)
  - getTickBars
```
@Deprecated
java.util.List<ITickBar> getTickBars(Instrument instrument,
                                                 OfferSide offerSide,
                                                 TickBarSize tickBarSize,
                                                 long from,
                                                 long to)
                                          throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, long, long).
    
    Returns Tick Bars for specified instrument, offer side and tick bar size. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too Subscribe to Tick Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Tick Bars
    
    offerSide - offer side of Tick Bars
    
    tickBarSize - tick bar size of Tick Bars
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    Returns:
    
    loaded Tick Bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getTickBars
```
@Deprecated
java.util.List<ITickBar> getTickBars(Instrument instrument,
                                                 OfferSide offerSide,
                                                 TickBarSize tickBarSize,
                                                 int numberOfBarsBefore,
                                                 long time,
                                                 int numberOfBarsAfter)
                                          throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int, long, int).
    
    Returns Tick Bars for specified instrument, offer side and tick bar size. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException. If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too Subscribe to Tick Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - instrument of the tick bars
    
    offerSide - offer side of the tick bars
    
    tickBarSize - tick bar size of the tick bars
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when desired data amount is negative, etc; or some error occurs when loading data
  - readTickBars
```
@Deprecated
void readTickBars(Instrument instrument,
                              OfferSide offerSide,
                              TickBarSize tickBarSize,
                              long from,
                              long to,
                              ITickBarFeedListener listener,
                              LoadingProgressListener loadingProgress)
                       throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Tick Bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone.
    Subscribe to Tick Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Tick Bars
    
    offerSide - offer side of Tick Bars
    
    tickBarSize - tick bar size of Tick Bars
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - readTickBars
```
@Deprecated
void readTickBars(Instrument instrument,
                              OfferSide offerSide,
                              TickBarSize tickBarSize,
                              int numberOfBarsBefore,
                              long time,
                              int numberOfBarsAfter,
                              ITickBarFeedListener listener,
                              LoadingProgressListener loadingProgress)
                       throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Tick Bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone.
    Subscribe to Tick Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Tick Bars
    
    offerSide - offer side of Tick Bars
    
    tickBarSize - tick bar size of Tick Bars
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getRangeBars
```
@Deprecated
java.util.List<IRangeBar> getRangeBars(Instrument instrument,
                                                   OfferSide offerSide,
                                                   PriceRange priceRange,
                                                   long from,
                                                   long to)
                                            throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, long, long).
    
    Returns Range Bars for specified instrument, offer side and price range. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT). Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too Subscribe to Range Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Range Bars
    
    offerSide - offer side of Range Bars
    
    priceRange - price range of Range Bars
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    Returns:
    
    loaded Range Bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getRangeBars
```
@Deprecated
java.util.List<IRangeBar> getRangeBars(Instrument instrument,
                                                   OfferSide offerSide,
                                                   PriceRange priceRange,
                                                   int numberOfBarsBefore,
                                                   long time,
                                                   int numberOfBarsAfter)
                                            throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int, long, int).
    
    Returns Range Bars for specified instrument, offer side and price range. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT). Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException. If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too Subscribe to Range Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - instrument of the Range bars
    
    offerSide - offer side of the Range bars
    
    priceRange - price range of the Range bars
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when desired data amount is negative, etc; or some error occurs when loading data
  - readRangeBars
```
@Deprecated
void readRangeBars(Instrument instrument,
                               OfferSide offerSide,
                               PriceRange priceRange,
                               long from,
                               long to,
                               IRangeBarFeedListener listener,
                               LoadingProgressListener loadingProgress)
                        throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Range Bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT).
    Subscribe to Range Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Range Bars
    
    offerSide - offer side of Range Bars
    
    priceRange - price range of Range Bars
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - readRangeBars
```
@Deprecated
void readRangeBars(Instrument instrument,
                               OfferSide offerSide,
                               PriceRange priceRange,
                               int numberOfBarsBefore,
                               long time,
                               int numberOfBarsAfter,
                               IRangeBarFeedListener listener,
                               LoadingProgressListener loadingProgress)
                        throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Range Bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT).
    Subscribe to Range Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Range Bars
    
    offerSide - offer side of Range Bars
    
    priceRange - price range of Range Bars
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getRangeBar
```
@Deprecated
IRangeBar getRangeBar(Instrument instrument,
                                  OfferSide offerSide,
                                  PriceRange priceRange,
                                  int shift)
                           throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int).
    
    Returns range bar for specified instrument, offer side and price range, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar, 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone and default data interpolation descriptor (DataInterpolationDescriptor.DEFAULT).
    
    Parameters:
    
    instrument - instrument of the range bar
    
    offerSide - bid or ask side of the range bar
    
    priceRange - price range of the range bar
    
    shift - number of range bar back in time staring from current range bar. 1 - previous range bar, 2 - current range bar minus 2 bars and so on
    
    Returns:
    
    range bar or null if no bar is loaded
    
    Throws:
    
    JFException - when shift value is negative or instrument is not active (not opened in platform)
  - getRenkoBar
```
@Deprecated
IRenkoBar getRenkoBar(Instrument instrument,
                                  OfferSide offerSide,
                                  PriceRange brickSize,
                                  int shift)
                           throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int).
    
    Returns renko bar for specified instrument, offer side and brick size, that is shifted back in time for number in bars specified in shift parameter, 0 - current bar, 1 - previous bar (last formed bar) If there is no bar loaded at that position, then function returns null. This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone, default renko session (Period.ONE_MIN) and default price point (RenkoCreationPoint.CLOSE).
    
    Parameters:
    
    instrument - instrument of the Renko bar
    
    offerSide - bid or ask side of the Renko bar
    
    brickSize - price range of the Renko bar
    
    shift - number of bar back in time staring from current bar. 1 - previous bar, 2 - current bar minus 2 bars and so on
    
    Returns:
    
    Renko bar or null if no bar is loaded
    
    Throws:
    
    JFException - when shift value is negative or instrument is not active (not opened in platform)
  - getRenkoBars
```
@Deprecated
java.util.List<IRenkoBar> getRenkoBars(Instrument instrument,
                                                   OfferSide offerSide,
                                                   PriceRange brickSize,
                                                   long from,
                                                   long to)
                                            throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, long, long).
    
    Returns Renko Bars for specified instrument, offer side and brick size. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone, default renko session (Period.ONE_MIN) and default price point (RenkoCreationPoint.CLOSE).
    Subscribe to Renko Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Renko Bars
    
    offerSide - offer side of Renko Bars
    
    brickSize - price range of Renko Bars
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    Returns:
    
    loaded Renko Bars
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - getRenkoBars
```
@Deprecated
java.util.List<IRenkoBar> getRenkoBars(Instrument instrument,
                                                   OfferSide offerSide,
                                                   PriceRange brickSize,
                                                   int numberOfBarsBefore,
                                                   long time,
                                                   int numberOfBarsAfter)
                                            throws JFException
```
    Deprecated. use getFeedData(ITailoredFeedDescriptor, int, long, int).
    
    Returns Renko Bars for specified instrument, offer side and brick size. Method blocks until all data will be loaded from the server into local cache and then read and stored in collection. Because all the data is loaded into the memory, this method should be used with caution to not load too much data which can lead to OutOfMemoryException. If the requested period includes the bar that is not fully formed yet (in-progress bar), then it is included in result too This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone, default renko session (Period.ONE_MIN) and default price point (RenkoCreationPoint.CLOSE).
    Subscribe to Renko Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - instrument of the Renko bars
    
    offerSide - offer side of the Renko bars
    
    brickSize - price range of the Renko bars
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    Returns:
    
    loaded bars
    
    Throws:
    
    JFException - when desired data amount is negative, etc; or some error occurs when loading data
  - readRenkoBars
```
@Deprecated
void readRenkoBars(Instrument instrument,
                               OfferSide offerSide,
                               PriceRange brickSize,
                               long from,
                               long to,
                               IRenkoBarFeedListener listener,
                               LoadingProgressListener loadingProgress)
                        throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, long, long, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Renko Bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone, default renko session (Period.ONE_MIN) and default price point (RenkoCreationPoint.CLOSE).
    Subscribe to Renko Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Renko Bars
    
    offerSide - offer side of Renko Bars
    
    brickSize - price range of Renko Bars
    
    from - start time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the first loaded bar
    
    to - end time of the time interval for which bars should be loaded. This time is included in interval [start; end] of the last loaded bar
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data
  - readRenkoBars
```
@Deprecated
void readRenkoBars(Instrument instrument,
                               OfferSide offerSide,
                               PriceRange brickSize,
                               int numberOfBarsBefore,
                               long time,
                               int numberOfBarsAfter,
                               IRenkoBarFeedListener listener,
                               LoadingProgressListener loadingProgress)
                        throws JFException
```
    Deprecated. use readFeedData(ITailoredFeedDescriptor, int, long, int, ITailoredFeedListener, LoadingProgressListener).
    
    Reads Renko Bars from the local cache in the background. Method returns fast after creating request for data not waiting for any data to be read from local cache. After internal request is sent, bars will be returned by calling method in listener. LoadingProgressListener is used to receive feedback about loading progress, to cancel loading and its method LoadingProgressListener.loadingFinished(boolean, long, long, long) is called when loading is finished or as a result of error This method has two main purposes: one is to load a lot of bars without keeping them all in memory, and second is asynchronous processing This method uses default base period IFeedDescriptor.DEFAULT_BASE_PERIOD, which has EET time zone, default renko session (Period.ONE_MIN) and default price point (RenkoCreationPoint.CLOSE).
    Subscribe to Renko Bar live notification first, before call this method.
    
    Parameters:
    
    instrument - of Renko Bars
    
    offerSide - offer side of Renko Bars
    
    brickSize - price range of Renko Bars
    
    numberOfBarsBefore - how much bars to load before and including bar with time specified in time parameter
    
    time - time of the last bar in period specified in numberOfBarsBefore parameter, or time of the first bar in period specified with numberOfBarsAfter parameter if numberOfBarsBefore is 0, or time of the candle prior to first candle in period specified with numberOfBarsAfter if numberOfBarsBefore is > 0
    
    numberOfBarsAfter - how much bars to load after (not including) bar with time specified in time parameter
    
    listener - receives data about requested bars
    
    loadingProgress - used to control loading progress
    
    Throws:
    
    JFException - when incorrect time interval is passed or some error occurs when loading data

Interface IHistory

Method Summary

Method Detail

getTimeOfLastTick

getLastTick

getStartTimeOfCurrentBar

getBar

readTicks

readTicks

readBars

readBars

readBars

getTicks

getTicks

getBars

getBars

getBars

getBarStart

getNextBarStart

getPreviousBarStart

getTimeForNBarsBack

getTimeForNBarsForward

readOrdersHistory

getOrdersHistory

getHistoricalOrderById

getOpenOrders

getEquity

getTick

getFeedData

getFeedData

getFeedData

getFeedData

getFeedData

getFeedData

getFeedData

readFeedData

readFeedData

readFeedData

readFeedData

readFeedData

readFeedData

readTicks

getBars

getFeedData

getFeedData

getTimeOfLastTick

getLastTick

getStartTimeOfCurrentBar

getBar

readTicks

readBars

readBars

readBars

getTicks

getTicks

getBars

getBars

readOrdersHistory

getOrdersHistory

getOpenOrders

getTick

getFeedData

getFeedData

getFeedData

readFeedData

readFeedData

readFeedData

readFeedData

getPointAndFigure

getPointAndFigures

getPointAndFigures

readPointAndFigures

readPointAndFigures

getTickBar

getTickBars

getTickBars

readTickBars

readTickBars

getRangeBars

getRangeBars