derivato da nique_372/MQLArticles
//+------------------------------------------------------------------+
| |
//| Pool.mqh |
| |
//| Copyright 2026, Niquel Mendoza. |
| |
//| https://www.mql5.com |
| |
//+------------------------------------------------------------------+
| |
#property copyright "Copyright 2026, Niquel Mendoza."
| |
#property link "https://www.mql5.com"
| |
#property strict
| |
| |
#ifndef MQLARTICLES_INDICATORCTS_IMP_CODE_POOL_MQH
| |
#define MQLARTICLES_INDICATORCTS_IMP_CODE_POOL_MQH
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
#include "PoolDef.mqh"
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
namespace TSN
| |
{
| |
//+------------------------------------------------------------------+
| |
//| Cache de indicadores |
| |
//+------------------------------------------------------------------+
| |
class CIndicatorCache
| |
{
| |
private:
| |
//---
| |
static TSN::CHashMapFastNor<TSN::CBitBuffer, int, TSN::CGenericHash_CBitBuffer> s_hash_str_to_int;
| |
static bool s_is_active;
| |
static CBitBuffer s_bit;
| |
| |
//--- Rsi
| |
static CiRsi* s_rsi[];
| |
static IndicatorCacheExtraData s_rsi_data[];
| |
static int s_rsi_size;
| |
static int s_rsi_r;
| |
| |
//--- Ma
| |
static CiMa* s_ma[];
| |
static IndicatorCacheExtraData s_ma_data[];
| |
static int s_ma_size;
| |
static int s_ma_r;
| |
| |
//--- Cci
| |
static CiCci* s_cci[];
| |
static IndicatorCacheExtraData s_cci_data[];
| |
static int s_cci_size;
| |
static int s_cci_r;
| |
| |
//--- Stochastic
| |
static CiStocastic* s_stochastic[];
| |
static IndicatorCacheExtraData s_stochastic_data[];
| |
static int s_stochastic_size;
| |
static int s_stochastic_r;
| |
| |
//--- Vidya
| |
static CiVIDyA* s_vidya[];
| |
static IndicatorCacheExtraData s_vidya_data[];
| |
static int s_vidya_size;
| |
static int s_vidya_r;
| |
| |
//--- Bands
| |
static CiBands* s_bands[];
| |
static IndicatorCacheExtraData s_bands_data[];
| |
static int s_bands_size;
| |
static int s_bands_r;
| |
| |
//--- AD
| |
static CiAD* s_ad[];
| |
static IndicatorCacheExtraData s_ad_data[];
| |
static int s_ad_size;
| |
static int s_ad_r;
| |
| |
//--- Obv
| |
static CiObv* s_obv[];
| |
static IndicatorCacheExtraData s_obv_data[];
| |
static int s_obv_size;
| |
static int s_obv_r;
| |
| |
//--- StdDev
| |
static CiStandartDeviation* s_std_dev[];
| |
static IndicatorCacheExtraData s_std_dev_data[];
| |
static int s_std_dev_size;
| |
static int s_std_dev_r;
| |
| |
//--- Sar
| |
static CiSar* s_sar[];
| |
static IndicatorCacheExtraData s_sar_data[];
| |
static int s_sar_size;
| |
static int s_sar_r;
| |
| |
//--- Adx
| |
static CiAdx* s_adx[];
| |
static IndicatorCacheExtraData s_adx_data[];
| |
static int s_adx_size;
| |
static int s_adx_r;
| |
| |
//--- AdxWilder
| |
static CiAdxWilder* s_adx_wilder[];
| |
static IndicatorCacheExtraData s_adx_wilder_data[];
| |
static int s_adx_wilder_size;
| |
static int s_adx_wilder_r;
| |
| |
//--- SuperTrend
| |
static CiSuperTrend* s_super_trend[];
| |
static IndicatorCacheExtraData s_super_trend_data[];
| |
static int s_super_trend_size;
| |
static int s_super_trend_r;
| |
| |
//--- Vwap
| |
static CiVwapChange* s_vwap[];
| |
static IndicatorCacheExtraData s_vwap_data[];
| |
static int s_vwap_size;
| |
static int s_vwap_r;
| |
| |
//--- Funcion template para remover
| |
template <typename T>
| |
static bool RemoveFromArray(T* &element, T* &array[], IndicatorCacheExtraData &data[], int &size);
| |
| |
public:
| |
CIndicatorCache(void) {}
| |
~CIndicatorCache(void) {}
| |
| |
//--- Init - Deinit
| |
static void Init();
| |
static void Deinit(const int reason);
| |
| |
//--- IsActive
| |
static __forceinline bool IsActive() { return s_is_active; }
| |
| |
//--- Rsi
| |
static CiRsi* GetRsi(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int period, ENUM_APPLIED_PRICE applied);
| |
static __forceinline bool RemoveRsi(CiRsi* element) { return RemoveFromArray(element, s_rsi, s_rsi_data, s_rsi_size); }
| |
| |
//--- Ma
| |
static CiMa* GetMa(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int period, int ma_shift, ENUM_MA_METHOD ma_method, ENUM_APPLIED_PRICE applied);
| |
static __forceinline bool RemoveMa(CiMa* element) { return RemoveFromArray(element, s_ma, s_ma_data, s_ma_size); }
| |
| |
//--- Cci
| |
static CiCci* GetCci(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int period, ENUM_APPLIED_PRICE applied);
| |
static __forceinline bool RemoveCci(CiCci* element) { return RemoveFromArray(element, s_cci, s_cci_data, s_cci_size); }
| |
| |
//--- Stochastic
| |
static CiStocastic* GetStochastic(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int kperiod, int dperiod, int slowing, ENUM_MA_METHOD ma_method, ENUM_STO_PRICE stop_price);
| |
static __forceinline bool RemoveStochastic(CiStocastic* element) { return RemoveFromArray(element, s_stochastic, s_stochastic_data, s_stochastic_size); }
| |
| |
//--- Vidya
| |
static CiVIDyA* GetVidya(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int cmo_period, int ema_period, int ma_shift, ENUM_APPLIED_PRICE applied);
| |
static __forceinline bool RemoveVidya(CiVIDyA* element) { return RemoveFromArray(element, s_vidya, s_vidya_data, s_vidya_size); }
| |
| |
//--- Bands
| |
static CiBands* GetBands(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int bands_period, int bands_shift, double deviation, ENUM_APPLIED_PRICE applied_price);
| |
static __forceinline bool RemoveBands(CiBands* element) { return RemoveFromArray(element, s_bands, s_bands_data, s_bands_size); }
| |
| |
//--- AD
| |
static CiAD* GetAD(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, ENUM_APPLIED_VOLUME applied);
| |
static __forceinline bool RemoveAD(CiAD* element) { return RemoveFromArray(element, s_ad, s_ad_data, s_ad_size); }
| |
| |
//--- Obv
| |
static CiObv* GetObv(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, ENUM_APPLIED_VOLUME applied);
| |
static __forceinline bool RemoveObv(CiObv* element) { return RemoveFromArray(element, s_obv, s_obv_data, s_obv_size); }
| |
| |
//--- StdDev
| |
static CiStandartDeviation* GetStdDev(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int ma_period, int ma_shift, ENUM_MA_METHOD ma_method, ENUM_APPLIED_PRICE applied);
| |
static __forceinline bool RemoveStdDev(CiStandartDeviation* element) { return RemoveFromArray(element, s_std_dev, s_std_dev_data, s_std_dev_size); }
| |
| |
//--- Sar
| |
static CiSar* GetSar(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, double step, double maxium);
| |
static __forceinline bool RemoveSar(CiSar* element) { return RemoveFromArray(element, s_sar, s_sar_data, s_sar_size); }
| |
| |
//--- Adx
| |
static CiAdx* GetAdx(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int ma_period);
| |
static __forceinline bool RemoveAdx(CiAdx* element) { return RemoveFromArray(element, s_adx, s_adx_data, s_adx_size); }
| |
| |
//--- AdxWilder
| |
static CiAdxWilder* GetAdxWilder(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int ma_period);
| |
static __forceinline bool RemoveAdxWilder(CiAdxWilder* element) { return RemoveFromArray(element, s_adx_wilder, s_adx_wilder_data, s_adx_wilder_size); }
| |
| |
//--- SuperTrend
| |
static CiSuperTrend* GetSuperTrend(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int cci_period, ENUM_APPLIED_PRICE applied, int atr_period);
| |
static __forceinline bool RemoveSuperTrend(CiSuperTrend* element) { return RemoveFromArray(element, s_super_trend, s_super_trend_data, s_super_trend_size); }
| |
| |
//--- Vwap
| |
static CiVwapChange* GetVwap(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, ENUM_VWAP_Period period, ENUM_APPLIED_PRICE applied);
| |
static __forceinline bool RemoveVwap(CiVwapChange* element) { return RemoveFromArray(element, s_vwap, s_vwap_data, s_vwap_size); }
| |
| |
};
| |
| |
//+------------------------------------------------------------------+
| |
//| Init |
| |
//+------------------------------------------------------------------+
| |
static void CIndicatorCache::Init(void)
| |
{
| |
if(s_is_active)
| |
return;
| |
| |
//---
| |
s_is_active = true;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
template <typename T>
| |
static bool CIndicatorCache::RemoveFromArray(T* &element, T* &array[], IndicatorCacheExtraData &data[], int &size)
| |
{
| |
//---
| |
const ENUM_POINTER_TYPE ptr_type = CheckPointer(element);
| |
if(ptr_type == POINTER_INVALID)
| |
{
| |
FastLog(FUNCION_ACTUAL, ERROR_TEXT, StringFormat("se esta intentando eliminar un elemento INVALIDO, type = %s", typename(T)));
| |
return false;
| |
}
| |
| |
//--- Find
| |
int idx = -1;
| |
for(int i = 0; i < size; i++)
| |
{
| |
if(array[i] == element)
| |
{
| |
idx = i;
| |
break;
| |
}
| |
}
| |
| |
//--- Verificamos si existe
| |
if(idx == -1)
| |
{
| |
FastLog(FUNCION_ACTUAL, ERROR_TEXT, "El puntero que se busca eliminar ya no existe");
| |
return false;
| |
}
| |
| |
//--- Reducimos y comparamos, en caso ser menor o igual a 0 se termino para esta "key" lo eliminamos
| |
if(--data[idx].ref_count <= 0)
| |
{
| |
//--- Eliminar objeto, solo si es DINAMICO
| |
if(ptr_type == POINTER_DYNAMIC)
| |
delete array[idx];
| |
| |
//--- Removemos del hashmap
| |
if(!s_hash_str_to_int.Remove(data[idx]))
| |
{
| |
FastLog(FUNCION_ACTUAL, CRITICAL_ERROR_TEXT,
| |
StringFormat("No se pudo eliminar el key con hash = '%I64u'", CGenericHash_CBitBuffer::Hash(data[idx])));
| |
return false;
| |
}
| |
| |
//--- Swap con el ultimo elemento
| |
const int last = --size;
| |
bool res = true;
| |
if(last != idx)
| |
{
| |
array[idx] = array[last]; // puntero
| |
data[idx].RobarDe(data[last]); // data
| |
// Nota aqui el objeto que estaba en LAST ahora estara en la posicion IDX por loq ue key es de LAST
| |
res = s_hash_str_to_int.TrySet(data[idx], idx);
| |
}
| |
| |
//---
| |
return res;
| |
}
| |
| |
//--- exito en eliminar (Aqunue como tal no se elimino la ref)
| |
return true;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiRsi* CIndicatorCache::GetRsi(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int period, ENUM_APPLIED_PRICE applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Rsi");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(period);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_rsi_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_rsi, s_rsi_data, s_rsi_size, s_rsi_r)
| |
| |
//---
| |
s_rsi[idx] = new CiRsi();
| |
if(!s_rsi[idx].Create(timeframe, symbol, series, hide, period, applied))
| |
{
| |
delete s_rsi[idx];
| |
s_rsi_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_rsi_data[idx] = s_bit; // #1 Copia
| |
s_rsi_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_rsi_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_rsi[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiMa* CIndicatorCache::GetMa(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int period, int ma_shift, ENUM_MA_METHOD ma_method, ENUM_APPLIED_PRICE applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Ma");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(period);
| |
s_bit.WriteInteger(ma_shift);
| |
s_bit.WriteInteger(ma_method);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_ma_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_ma, s_ma_data, s_ma_size, s_ma_r)
| |
| |
//---
| |
s_ma[idx] = new CiMa();
| |
if(!s_ma[idx].Create(timeframe, symbol, series, hide, period, ma_shift, ma_method, applied))
| |
{
| |
delete s_ma[idx];
| |
s_ma_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_ma_data[idx] = s_bit; // #1 Copia
| |
s_ma_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_ma_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_ma[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiCci* CIndicatorCache::GetCci(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int period, ENUM_APPLIED_PRICE applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Cci");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(period);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_cci_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_cci, s_cci_data, s_cci_size, s_cci_r)
| |
| |
//---
| |
s_cci[idx] = new CiCci();
| |
if(!s_cci[idx].Create(timeframe, symbol, series, hide, period, applied))
| |
{
| |
delete s_cci[idx];
| |
s_cci_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_cci_data[idx] = s_bit; // #1 Copia
| |
s_cci_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_cci_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_cci[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiStocastic* CIndicatorCache::GetStochastic(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int kperiod, int dperiod, int slowing, ENUM_MA_METHOD ma_method, ENUM_STO_PRICE stop_price)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Stochastic");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(kperiod);
| |
s_bit.WriteInteger(dperiod);
| |
s_bit.WriteInteger(slowing);
| |
s_bit.WriteInteger(ma_method);
| |
s_bit.WriteInteger(stop_price);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_stochastic_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_stochastic, s_stochastic_data, s_stochastic_size, s_stochastic_r)
| |
| |
//---
| |
s_stochastic[idx] = new CiStocastic();
| |
if(!s_stochastic[idx].Create(timeframe, symbol, series, hide, kperiod, dperiod, slowing, ma_method, stop_price))
| |
{
| |
delete s_stochastic[idx];
| |
s_stochastic_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_stochastic_data[idx] = s_bit; // #1 Copia
| |
s_stochastic_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_stochastic_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_stochastic[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiVIDyA* CIndicatorCache::GetVidya(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int cmo_period, int ema_period, int ma_shift, ENUM_APPLIED_PRICE applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Vidya");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(cmo_period);
| |
s_bit.WriteInteger(ema_period);
| |
s_bit.WriteInteger(ma_shift);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_vidya_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_vidya, s_vidya_data, s_vidya_size, s_vidya_r)
| |
| |
//---
| |
s_vidya[idx] = new CiVIDyA();
| |
if(!s_vidya[idx].Create(timeframe, symbol, series, hide, cmo_period, ema_period, ma_shift, applied))
| |
{
| |
delete s_vidya[idx];
| |
s_vidya_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_vidya_data[idx] = s_bit; // #1 Copia
| |
s_vidya_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_vidya_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_vidya[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiBands* CIndicatorCache::GetBands(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int bands_period, int bands_shift, double deviation, ENUM_APPLIED_PRICE applied_price)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Bands");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(bands_period);
| |
s_bit.WriteInteger(bands_shift);
| |
s_bit.WriteDouble(NormalizeDouble(deviation, INDICATOR_CACHE_DBL_DIG));
| |
s_bit.WriteInteger(applied_price);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_bands_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_bands, s_bands_data, s_bands_size, s_bands_r)
| |
| |
//---
| |
s_bands[idx] = new CiBands();
| |
if(!s_bands[idx].Create(timeframe, symbol, series, hide, bands_period, bands_shift, deviation, applied_price))
| |
{
| |
delete s_bands[idx];
| |
s_bands_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_bands_data[idx] = s_bit; // #1 Copia
| |
s_bands_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_bands_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_bands[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiAD* CIndicatorCache::GetAD(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, ENUM_APPLIED_VOLUME applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("AD");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_ad_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_ad, s_ad_data, s_ad_size, s_ad_r)
| |
| |
//---
| |
s_ad[idx] = new CiAD();
| |
if(!s_ad[idx].Create(timeframe, symbol, series, hide, applied))
| |
{
| |
delete s_ad[idx];
| |
s_ad_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_ad_data[idx] = s_bit; // #1 Copia
| |
s_ad_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_ad_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_ad[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiObv* CIndicatorCache::GetObv(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, ENUM_APPLIED_VOLUME applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Obv");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_obv_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_obv, s_obv_data, s_obv_size, s_obv_r)
| |
| |
//---
| |
s_obv[idx] = new CiObv();
| |
if(!s_obv[idx].Create(timeframe, symbol, series, hide, applied))
| |
{
| |
delete s_obv[idx];
| |
s_obv_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_obv_data[idx] = s_bit; // #1 Copia
| |
s_obv_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_obv_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_obv[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiStandartDeviation* CIndicatorCache::GetStdDev(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int ma_period, int ma_shift, ENUM_MA_METHOD ma_method, ENUM_APPLIED_PRICE applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("StdDev");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(ma_period);
| |
s_bit.WriteInteger(ma_shift);
| |
s_bit.WriteInteger(ma_method);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_std_dev_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_std_dev, s_std_dev_data, s_std_dev_size, s_std_dev_r)
| |
| |
//---
| |
s_std_dev[idx] = new CiStandartDeviation();
| |
if(!s_std_dev[idx].Create(timeframe, symbol, series, hide, ma_period, ma_shift, ma_method, applied))
| |
{
| |
delete s_std_dev[idx];
| |
s_std_dev_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_std_dev_data[idx] = s_bit; // #1 Copia
| |
s_std_dev_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_std_dev_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_std_dev[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiSar* CIndicatorCache::GetSar(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, double step, double maxium)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Sar");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteDouble(NormalizeDouble(step, INDICATOR_CACHE_DBL_DIG));
| |
s_bit.WriteDouble(NormalizeDouble(maxium, INDICATOR_CACHE_DBL_DIG));
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_sar_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_sar, s_sar_data, s_sar_size, s_sar_r)
| |
| |
//---
| |
s_sar[idx] = new CiSar();
| |
if(!s_sar[idx].Create(timeframe, symbol, series, hide, step, maxium))
| |
{
| |
delete s_sar[idx];
| |
s_sar_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_sar_data[idx] = s_bit; // #1 Copia
| |
s_sar_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_sar_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_sar[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiAdx* CIndicatorCache::GetAdx(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int ma_period)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Adx");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(ma_period);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_adx_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_adx, s_adx_data, s_adx_size, s_adx_r)
| |
| |
//---
| |
s_adx[idx] = new CiAdx();
| |
if(!s_adx[idx].Create(timeframe, symbol, series, hide, ma_period))
| |
{
| |
delete s_adx[idx];
| |
s_adx_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_adx_data[idx] = s_bit; // #1 Copia
| |
s_adx_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_adx_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_adx[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiAdxWilder* CIndicatorCache::GetAdxWilder(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int ma_period)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("AdxWilder");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(ma_period);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_adx_wilder_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_adx_wilder, s_adx_wilder_data, s_adx_wilder_size, s_adx_wilder_r)
| |
| |
//---
| |
s_adx_wilder[idx] = new CiAdxWilder();
| |
if(!s_adx_wilder[idx].Create(timeframe, symbol, series, hide, ma_period))
| |
{
| |
delete s_adx_wilder[idx];
| |
s_adx_wilder_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_adx_wilder_data[idx] = s_bit; // #1 Copia
| |
s_adx_wilder_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_adx_wilder_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_adx_wilder[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiSuperTrend* CIndicatorCache::GetSuperTrend(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, int cci_period, ENUM_APPLIED_PRICE applied, int atr_period)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("SuperTrend");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(cci_period);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteInteger(atr_period);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_super_trend_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_super_trend, s_super_trend_data, s_super_trend_size, s_super_trend_r)
| |
| |
//---
| |
s_super_trend[idx] = new CiSuperTrend();
| |
if(!s_super_trend[idx].Create(timeframe, symbol, series, hide, cci_period, applied, atr_period))
| |
{
| |
delete s_super_trend[idx];
| |
s_super_trend_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_super_trend_data[idx] = s_bit; // #1 Copia
| |
s_super_trend_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_super_trend_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_super_trend[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static CiVwapChange* CIndicatorCache::GetVwap(ENUM_TIMEFRAMES timeframe, string symbol, bool series, bool hide, ENUM_VWAP_Period period, ENUM_APPLIED_PRICE applied)
| |
{
| |
//--- Normalizamos timeframe
| |
if(timeframe == PERIOD_CURRENT)
| |
timeframe = _Period;
| |
| |
//--- Key
| |
s_bit.Clear();
| |
s_bit.WriteStringWPadd("Vwap");
| |
s_bit.WriteStringWPadd(symbol);
| |
s_bit.WriteInteger(timeframe);
| |
s_bit.WriteInteger(period);
| |
s_bit.WriteInteger(applied);
| |
s_bit.WriteBool(series);
| |
| |
//--- Verificamos si existe en caso no existe lo creamos
| |
int idx;
| |
if(s_hash_str_to_int.ReserveSlot(s_bit))
| |
{
| |
//---
| |
idx = s_vwap_size++;
| |
| |
//--- Arrays (el de punteros y el de datos crecen juntos)
| |
MQLA_INDPOOL_CRESERVE2(s_vwap, s_vwap_data, s_vwap_size, s_vwap_r)
| |
| |
//---
| |
s_vwap[idx] = new CiVwapChange();
| |
if(!s_vwap[idx].Create(timeframe, symbol, series, hide, period, applied))
| |
{
| |
delete s_vwap[idx];
| |
s_vwap_size--;
| |
s_hash_str_to_int.RemoveLastFindCall(); // ultimo call
| |
return NULL;
| |
}
| |
| |
//--- copia por =
| |
(CBitBuffer&)s_vwap_data[idx] = s_bit; // #1 Copia
| |
s_vwap_data[idx].ref_count = 1;
| |
| |
//--- Hashmap
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
s_hash_str_to_int.m_table[p].key.RobarDe(s_bit);
| |
s_hash_str_to_int.m_table[p].value = idx;
| |
s_bit.SyncArrayRSize(); // esto por el swap tenemos que acutlizar r
| |
}
| |
else
| |
{
| |
const uint p = s_hash_str_to_int.m_last_pos_tbl;
| |
idx = s_hash_str_to_int.m_table[p].value;
| |
s_vwap_data[idx].ref_count++;
| |
}
| |
| |
//--- Retornamos puntero
| |
return s_vwap[idx];
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Deinit |
| |
//+------------------------------------------------------------------+
| |
static void CIndicatorCache::Deinit(const int reason)
| |
{
| |
//---
| |
if(!s_is_active)
| |
return;
| |
| |
//--- Rsi
| |
if(s_rsi_size)
| |
{
| |
for(int i = 0; i < s_rsi_size; i++)
| |
if(CheckPointer(s_rsi[i]) == POINTER_DYNAMIC)
| |
delete s_rsi[i];
| |
s_rsi_size = 0;
| |
}
| |
| |
//--- Ma
| |
if(s_ma_size)
| |
{
| |
for(int i = 0; i < s_ma_size; i++)
| |
if(CheckPointer(s_ma[i]) == POINTER_DYNAMIC)
| |
delete s_ma[i];
| |
s_ma_size = 0;
| |
}
| |
| |
//--- Cci
| |
if(s_cci_size)
| |
{
| |
for(int i = 0; i < s_cci_size; i++)
| |
if(CheckPointer(s_cci[i]) == POINTER_DYNAMIC)
| |
delete s_cci[i];
| |
s_cci_size = 0;
| |
}
| |
| |
//--- Stochastic
| |
if(s_stochastic_size)
| |
{
| |
for(int i = 0; i < s_stochastic_size; i++)
| |
if(CheckPointer(s_stochastic[i]) == POINTER_DYNAMIC)
| |
delete s_stochastic[i];
| |
s_stochastic_size = 0;
| |
}
| |
| |
//--- Vidya
| |
if(s_vidya_size)
| |
{
| |
for(int i = 0; i < s_vidya_size; i++)
| |
if(CheckPointer(s_vidya[i]) == POINTER_DYNAMIC)
| |
delete s_vidya[i];
| |
s_vidya_size = 0;
| |
}
| |
| |
//--- Bands
| |
if(s_bands_size)
| |
{
| |
for(int i = 0; i < s_bands_size; i++)
| |
if(CheckPointer(s_bands[i]) == POINTER_DYNAMIC)
| |
delete s_bands[i];
| |
s_bands_size = 0;
| |
}
| |
| |
//--- AD
| |
if(s_ad_size)
| |
{
| |
for(int i = 0; i < s_ad_size; i++)
| |
if(CheckPointer(s_ad[i]) == POINTER_DYNAMIC)
| |
delete s_ad[i];
| |
s_ad_size = 0;
| |
}
| |
| |
//--- Obv
| |
if(s_obv_size)
| |
{
| |
for(int i = 0; i < s_obv_size; i++)
| |
if(CheckPointer(s_obv[i]) == POINTER_DYNAMIC)
| |
delete s_obv[i];
| |
s_obv_size = 0;
| |
}
| |
| |
//--- StdDev
| |
if(s_std_dev_size)
| |
{
| |
for(int i = 0; i < s_std_dev_size; i++)
| |
if(CheckPointer(s_std_dev[i]) == POINTER_DYNAMIC)
| |
delete s_std_dev[i];
| |
s_std_dev_size = 0;
| |
}
| |
| |
//--- Sar
| |
if(s_sar_size)
| |
{
| |
for(int i = 0; i < s_sar_size; i++)
| |
if(CheckPointer(s_sar[i]) == POINTER_DYNAMIC)
| |
delete s_sar[i];
| |
s_sar_size = 0;
| |
}
| |
| |
//--- Adx
| |
if(s_adx_size)
| |
{
| |
for(int i = 0; i < s_adx_size; i++)
| |
if(CheckPointer(s_adx[i]) == POINTER_DYNAMIC)
| |
delete s_adx[i];
| |
s_adx_size = 0;
| |
}
| |
| |
//--- AdxWilder
| |
if(s_adx_wilder_size)
| |
{
| |
for(int i = 0; i < s_adx_wilder_size; i++)
| |
if(CheckPointer(s_adx_wilder[i]) == POINTER_DYNAMIC)
| |
delete s_adx_wilder[i];
| |
s_adx_wilder_size = 0;
| |
}
| |
| |
//--- SuperTrend
| |
if(s_super_trend_size)
| |
{
| |
for(int i = 0; i < s_super_trend_size; i++)
| |
if(CheckPointer(s_super_trend[i]) == POINTER_DYNAMIC)
| |
delete s_super_trend[i];
| |
s_super_trend_size = 0;
| |
}
| |
| |
//--- Vwap
| |
if(s_vwap_size)
| |
{
| |
for(int i = 0; i < s_vwap_size; i++)
| |
if(CheckPointer(s_vwap[i]) == POINTER_DYNAMIC)
| |
delete s_vwap[i];
| |
s_vwap_size = 0;
| |
}
| |
| |
//---
| |
s_is_active = false;
| |
}
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Inicializacion de variables estaticas |
| |
//+------------------------------------------------------------------+
| |
TSN::CHashMapFastNor<TSN::CBitBuffer, int, TSN::CGenericHash_CBitBuffer> CIndicatorCache::s_hash_str_to_int;
| |
bool CIndicatorCache::s_is_active = false;
| |
CBitBuffer CIndicatorCache::s_bit(32);
| |
| |
//--- Rsi
| |
CiRsi* CIndicatorCache::s_rsi[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_rsi_data[];
| |
int CIndicatorCache::s_rsi_size = 0;
| |
int CIndicatorCache::s_rsi_r = 0;
| |
| |
//--- Ma
| |
CiMa* CIndicatorCache::s_ma[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_ma_data[];
| |
int CIndicatorCache::s_ma_size = 0;
| |
int CIndicatorCache::s_ma_r = 0;
| |
| |
//--- Cci
| |
CiCci* CIndicatorCache::s_cci[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_cci_data[];
| |
int CIndicatorCache::s_cci_size = 0;
| |
int CIndicatorCache::s_cci_r = 0;
| |
| |
//--- Stochastic
| |
CiStocastic* CIndicatorCache::s_stochastic[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_stochastic_data[];
| |
int CIndicatorCache::s_stochastic_size = 0;
| |
int CIndicatorCache::s_stochastic_r = 0;
| |
| |
//--- Vidya
| |
CiVIDyA* CIndicatorCache::s_vidya[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_vidya_data[];
| |
int CIndicatorCache::s_vidya_size = 0;
| |
int CIndicatorCache::s_vidya_r = 0;
| |
| |
//--- Bands
| |
CiBands* CIndicatorCache::s_bands[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_bands_data[];
| |
int CIndicatorCache::s_bands_size = 0;
| |
int CIndicatorCache::s_bands_r = 0;
| |
| |
//--- AD
| |
CiAD* CIndicatorCache::s_ad[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_ad_data[];
| |
int CIndicatorCache::s_ad_size = 0;
| |
int CIndicatorCache::s_ad_r = 0;
| |
| |
//--- Obv
| |
CiObv* CIndicatorCache::s_obv[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_obv_data[];
| |
int CIndicatorCache::s_obv_size = 0;
| |
int CIndicatorCache::s_obv_r = 0;
| |
| |
//--- StdDev
| |
CiStandartDeviation* CIndicatorCache::s_std_dev[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_std_dev_data[];
| |
int CIndicatorCache::s_std_dev_size = 0;
| |
int CIndicatorCache::s_std_dev_r = 0;
| |
| |
//--- Sar
| |
CiSar* CIndicatorCache::s_sar[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_sar_data[];
| |
int CIndicatorCache::s_sar_size = 0;
| |
int CIndicatorCache::s_sar_r = 0;
| |
| |
//--- Adx
| |
CiAdx* CIndicatorCache::s_adx[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_adx_data[];
| |
int CIndicatorCache::s_adx_size = 0;
| |
int CIndicatorCache::s_adx_r = 0;
| |
| |
//--- AdxWilder
| |
CiAdxWilder* CIndicatorCache::s_adx_wilder[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_adx_wilder_data[];
| |
int CIndicatorCache::s_adx_wilder_size = 0;
| |
int CIndicatorCache::s_adx_wilder_r = 0;
| |
| |
//--- SuperTrend
| |
CiSuperTrend* CIndicatorCache::s_super_trend[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_super_trend_data[];
| |
int CIndicatorCache::s_super_trend_size = 0;
| |
int CIndicatorCache::s_super_trend_r = 0;
| |
| |
//--- Vwap
| |
CiVwapChange* CIndicatorCache::s_vwap[] = {};
| |
IndicatorCacheExtraData CIndicatorCache::s_vwap_data[];
| |
int CIndicatorCache::s_vwap_size = 0;
| |
int CIndicatorCache::s_vwap_r = 0;
| |
| |
//---
| |
}
| |
#endif // MQLARTICLES_INDICATORCTS_IMP_CODE_POOL_MQH
|