Merge remote-tracking branch 'origin/v3.004-dev-indi-rename' into v3.…

…008-dev-new

* origin/v3.004-dev-indi-rename:
  Moves Indicator and IndicatorBase into Indicator/

Indicator/Indicator.struct.cache.h

@@ -0,0 +1,268 @@
+//+------------------------------------------------------------------+
+//|                                                EA31337 framework |
+//|                                 Copyright 2016-2023, EA31337 Ltd |
+//|                                       https://github.com/EA31337 |
+//+------------------------------------------------------------------+
+
+/*
+ * This file is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * @file
+ * IndicatorBufferValueStorage class.
+ */
+
+#ifndef __MQL__
+// Allows the preprocessor to include a header file when it is needed.
+#pragma once
+#endif
+
+// Includes.
+#include "../Refs.mqh"
+#include "../Storage/ValueStorage.h"
+
+/**
+ * Holds buffers used to cache values calculated via OnCalculate methods.
+ */
+template <typename C>
+class IndicatorCalculateCache : public Dynamic {
+ public:
+  // Total number of calculated values.
+  int prev_calculated;
+
+  // Number of prices to use.
+  int total;
+
+  // Whether cache was initialized with price buffer.
+  bool initialized;
+
+  // Buffer to store input prices. Won't be deleted!
+  ValueStorage<C> *price_buffer;
+
+  // Buffer to store input open prices. Won't be deleted!
+  ValueStorage<C> *price_open_buffer;
+
+  // Buffer to store input high prices. Won't be deleted!
+  ValueStorage<C> *price_high_buffer;
+
+  // Buffer to store input low prices. Won't be deleted!
+  ValueStorage<C> *price_low_buffer;
+
+  // Buffer to store input close prices. Won't be deleted!
+  ValueStorage<C> *price_close_buffer;
+
+  // Buffers used for OnCalculate calculations.
+  ARRAY(IValueStorage *, buffers);
+
+  // Auxiliary caches related to this one.
+  ARRAY(IndicatorCalculateCache<C> *, subcaches);
+
+  /**
+   * Constructor.
+   */
+  IndicatorCalculateCache(int _buffers_size = 0) {
+    prev_calculated = 0;
+    total = 0;
+    initialized = false;
+    Resize(_buffers_size);
+  }
+
+  /**
+   * Destructor.
+   */
+  ~IndicatorCalculateCache() {
+    int i;
+
+    for (i = 0; i < ArraySize(buffers); ++i) {
+      if (buffers[i] != NULL) {
+        delete buffers[i];
+      }
+    }
+
+    for (i = 0; i < ArraySize(subcaches); ++i) {
+      if (subcaches[i] != NULL) {
+        delete subcaches[i];
+      }
+    }
+  }
+
+  /**
+   * Returns size of the current price buffer.
+   */
+  int GetTotal() { return price_buffer != NULL ? ArraySize(price_buffer) : ArraySize(price_open_buffer); }
+
+  /**
+   * Returns number of already calculated prices (bars).
+   */
+  int GetPrevCalculated() { return prev_calculated; }
+
+  /**
+   * Whether cache have any buffer.
+   */
+  bool HasBuffers() { return ArraySize(buffers) != 0; }
+
+  /**
+   * Returns number of added buffers.
+   */
+  int NumBuffers() { return ArraySize(buffers); }
+
+  /**
+   * Returns existing or new cache as a child of current one. Useful when indicator uses other indicators and requires
+   * unique caches for them.
+   */
+  IndicatorCalculateCache<C> *GetSubCache(int _idx) {
+    if (_idx >= ArraySize(subcaches)) {
+      ArrayResize(subcaches, _idx + 1, 10);
+    }
+
+    if (subcaches[_idx] == NULL) {
+      subcaches[_idx] = new IndicatorCalculateCache();
+    }
+
+    return subcaches[_idx];
+  }
+
+  /**
+   * Add buffer of the given type. Usage: AddBuffer<NativeBuffer>()
+   */
+  template <typename T>
+  int AddBuffer(int _num_buffers = 1) {
+    IValueStorage *_ptr;
+
+    while (_num_buffers-- > 0) {
+      _ptr = new T();
+      ArrayPushObject(buffers, _ptr);
+    }
+
+    return ArraySize(buffers) - 1;
+  }
+
+  /**
+   * Returns given calculation buffer.
+   */
+  template <typename D>
+  ValueStorage<D> *GetBuffer(int _index) {
+    return (ValueStorage<D> *)buffers[_index];
+  }
+
+  /**
+   * Returns main price buffer.
+   */
+  ValueStorage<C> *GetPriceBuffer() { return price_buffer; }
+
+  /**
+   * Returns given price buffer.
+   */
+  ValueStorage<C> *GetPriceBuffer(ENUM_APPLIED_PRICE _applied_price) {
+    switch (_applied_price) {
+      case PRICE_OPEN:
+        return price_open_buffer;
+      case PRICE_HIGH:
+        return price_high_buffer;
+      case PRICE_LOW:
+        return price_low_buffer;
+      case PRICE_CLOSE:
+        return price_close_buffer;
+    }
+    return NULL;
+  }
+
+  /**
+   * Sets price buffer for later use.
+   */
+  void SetPriceBuffer(ValueStorage<C> &_price, int _total = 0) {
+    price_buffer = &_price;
+
+    if (_total == 0) {
+      _total = _price.Size();
+    }
+
+    total = _total;
+
+    // Cache is ready to be used.
+    initialized = true;
+  }
+
+  /**
+   * Sets price buffers for later use.
+   */
+  void SetPriceBuffer(ValueStorage<C> &_price_open, ValueStorage<C> &_price_high, ValueStorage<C> &_price_low,
+                      ValueStorage<C> &_price_close, int _total = 0) {
+    price_open_buffer = &_price_open;
+    price_high_buffer = &_price_high;
+    price_low_buffer = &_price_low;
+    price_close_buffer = &_price_close;
+
+    if (_total == 0) {
+      _total = _price_open.Size();
+    }
+
+    total = _total;
+
+    // Cache is ready to be used.
+    initialized = true;
+  }
+
+  /**
+   * Resizes all buffers.
+   */
+  void Resize(int _buffers_size) {
+    for (int i = 0; i < ArraySize(buffers); ++i) {
+      buffers[i].Resize(_buffers_size, 65535);
+    }
+  }
+
+  /**
+   * Retrieves cached value from the given buffer.
+   */
+  template <typename D>
+  D GetValue(int _buffer_index, int _shift) {
+    return GetBuffer<D>(_buffer_index).Fetch(_shift).Get();
+  }
+
+  /**
+   * Retrieves _shift-th (0 = most recent) cached value from the given buffer.
+   *
+   * @todo Return DBL_MAX in case the index is out of array boundary.
+   */
+  template <typename D>
+  D GetTailValue(int _buffer_index, int _shift) {
+    ValueStorage<D> *_buff = GetBuffer<D>(_buffer_index);
+    int _index = _buff.IsSeries() ? _shift : (ArraySize(_buff) - _shift - 1);
+    return _buff[_index].Get();
+  }
+
+  /**
+   * Updates prev_calculated value used by indicator's OnCalculate method.
+   */
+  void SetPrevCalculated(int _prev_calculated) {
+    if (_prev_calculated == 0) {
+      ResetPrevCalculated();
+    } else {
+      prev_calculated = _prev_calculated;
+    }
+  }
+
+  /**
+   * Resets prev_calculated value used by indicator's OnCalculate method.
+   */
+  void ResetPrevCalculated() { prev_calculated = 0; }
+
+  /**
+   * Returns prev_calculated value used by indicator's OnCalculate method.
+   */
+  int GetPrevCalculated(int _prev_calculated) { return prev_calculated; }
+};