| //+------------------------------------------------------------------+
|
| //| Events.mqh |
|
| //| Niquel y Leo, Copyright 2025. |
|
| //| https://www.mql5.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Niquel y Leo, Copyright 2025"
|
| #property link "https://www.mql5.com"
|
| #property strict
|
|
|
|
|
| #ifndef MQLARTICLES_UTILS_FA_EVENTS_MQH
|
| #define MQLARTICLES_UTILS_FA_EVENTS_MQH
|
|
|
| //+------------------------------------------------------------------+
|
| //| Include |
|
| //+------------------------------------------------------------------+
|
| #include "Managers.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Clase base para los eventos basicos |
|
| //+------------------------------------------------------------------+
|
| class CAllClassEventsBasic : public CSpecializedManager
|
| {
|
| protected:
|
| bool m_is_global;
|
| int m_hijos_events_valid_idx[];
|
| int m_hijos_events_valid_idx_size;
|
|
|
| //--- Impidimos la instanciacion solo ptr.. pero se debe de asignar..
|
| CAllClassEventsBasic(const bool& is_g) : m_is_global(is_g), m_hijos_events_valid_idx_size(0) {}
|
|
|
| //--- Ocultamos
|
| void AddLogger(CLoggerBase* _logger, bool is_all_class);
|
| void AddLogger(CLoggerBase &_logger, bool is_all_class);
|
| bool RemoveLogger(CLoggerBase* _logger);
|
|
|
| //---
|
| void CleanItems(const string &den_name) override final;
|
| void CleanItemsNoDelete(const string& den_name) override final;
|
|
|
| public:
|
| ~CAllClassEventsBasic() {}
|
|
|
| //---
|
| void __SetGlobal(bool is_global);
|
|
|
| //---
|
| __forceinline bool IsGlobalInstance() { return m_is_global; }
|
|
|
| //--- Eventos basicos
|
| // Nota: Estos eventos son los basicos
|
| virtual void OnNewDay(const datetime& curr_time) {}
|
| virtual void OnNewWeek(const datetime& curr_time) {}
|
| virtual void OnNewMonth(const datetime& curr_time) {}
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CAllClassEventsBasic::CleanItems(const string &den_name)
|
| {
|
| m_hijos_events_valid_idx_size = ArrayResize(m_hijos_events_valid_idx, 0);
|
| CSpecializedManager::CleanItems(den_name);
|
| }
|
| //+------------------------------------------------------------------+
|
| void CAllClassEventsBasic::CleanItemsNoDelete(const string &den_name)
|
| {
|
| m_hijos_events_valid_idx_size = ArrayResize(m_hijos_events_valid_idx, 0);
|
| CSpecializedManager::CleanItemsNoDelete(den_name);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CAllClassEventsBasic::AddLogger(CLoggerBase* _logger, bool is_all_class)
|
| {
|
| //---
|
| if(!CheckPointer(_logger))
|
| {
|
| LogFatalError("El puntero *_logger es inválido", FUNCION_ACTUAL);
|
| return;
|
| }
|
|
|
| //---
|
| m_loggers[ArrayResize(m_loggers, (++m_loggers_total)) - 1] = _logger;
|
|
|
| //---
|
| if(is_all_class)
|
| m_hijos_events_valid_idx[ArrayResize(m_hijos_events_valid_idx, (++m_hijos_events_valid_idx_size)) - 1] = (m_loggers_total - 1);
|
|
|
| //---
|
| _logger.AddLogFlags(LogFlags());
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| __forceinline void CAllClassEventsBasic::AddLogger(CLoggerBase &_logger, bool is_all_class)
|
| {
|
| AddLogger(GetPointer(_logger), is_all_class);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| /*
|
| - [L1, L2, L3, L4, L5, L6, L7, L8]
|
| 0 3 5 7
|
|
|
| - Eliminar L4
|
|
|
| - [L1, L2, L3, L8, L5, L6, L7]
|
| 0 3 5
|
|
|
| - [0, 3, 7, 5]
|
|
|
| - [0, 5, 7]
|
|
|
| - [0, 5, 3]
|
| L1, L8,
|
|
|
| - El orden no improta...
|
| aqui eliminamos usando find + swap
|
| */
|
| bool CAllClassEventsBasic::RemoveLogger(CLoggerBase* _logger)
|
| {
|
| //---
|
| if(!CheckPointer(_logger))
|
| {
|
| LogError("Se esta removiendo un logger NULL", FUNCION_ACTUAL);
|
| }
|
|
|
| //---
|
| for(int i = 0; i < m_loggers_total; i++)
|
| {
|
| if(m_loggers[i] == _logger)
|
| {
|
| //---
|
| const int last_idx = --m_loggers_total;
|
| m_loggers[i] = m_loggers[last_idx];
|
| ArrayResize(m_loggers, m_loggers_total);
|
|
|
| //---
|
| for(int k = 0; k < m_hijos_events_valid_idx_size; k++)
|
| {
|
| if(m_hijos_events_valid_idx[k] == i)
|
| {
|
| m_hijos_events_valid_idx[k] = m_hijos_events_valid_idx[--m_hijos_events_valid_idx_size];
|
| ArrayResize(m_hijos_events_valid_idx, m_hijos_events_valid_idx_size);
|
| k--;
|
| }
|
| else
|
| if(m_hijos_events_valid_idx[k] == last_idx)
|
| {
|
| m_hijos_events_valid_idx[k] = i;
|
| }
|
| }
|
|
|
| //---
|
| LogInfo(StringFormat("Logger en índice %d removido. Total restante: %d", i, m_loggers_total), FUNCION_ACTUAL);
|
|
|
| //---
|
| return true;
|
| }
|
| }
|
|
|
| //---
|
| LogWarning("Logger no encontrado para remover", FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CAllClassEventsBasic::__SetGlobal(bool is_global)
|
| {
|
| m_is_global = is_global;
|
| for(int k = 0; k < m_hijos_events_valid_idx_size; k++)
|
| ((CAllClassEventsBasic*)m_loggers[m_hijos_events_valid_idx[k]]).__SetGlobal(is_global);
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Clase base para los eventos |
|
| //+------------------------------------------------------------------+
|
| #define BASICEVENT_REG_FLAG_ON_NEW_DAY (1)
|
| #define BASICEVENT_REG_FLAG_ON_NEW_WEEK (2)
|
| #define BASICEVENT_REG_FLAG_ON_NEW_MON (4)
|
|
|
| //---
|
| #define BASICEVENT_REG_ALL_FLAG (BASICEVENT_REG_FLAG_ON_NEW_DAY|BASICEVENT_REG_FLAG_ON_NEW_WEEK|BASICEVENT_REG_FLAG_ON_NEW_MON)
|
|
|
|
|
| //---
|
| class CBasicEvents
|
| {
|
| private:
|
| static CAllClassEventsBasic* m_on_new_day[];
|
| static int m_on_new_day_size;
|
|
|
| static CAllClassEventsBasic* m_on_new_week[];
|
| static int m_on_new_week_size;
|
|
|
| static CAllClassEventsBasic* m_on_new_mon[];
|
| static int m_on_new_mon_size;
|
|
|
| //---
|
| static void RemoveFromArrayFast(CAllClassEventsBasic* &array[], int &size, CAllClassEventsBasic* &ptr);
|
|
|
| public:
|
| CBasicEvents(void) {}
|
| ~CBasicEvents(void) {}
|
|
|
| //--- Registrar
|
| static void Register(CAllClassEventsBasic* ptr, const uint8_t flags);
|
| static void RegisterEvent(CAllClassEventsBasic* ptr, const uint8_t event);
|
|
|
| static void Unregister(CAllClassEventsBasic* ptr, const uint8_t flags);
|
| static void UnregisterEvent(CAllClassEventsBasic* ptr, const uint8_t event);
|
|
|
|
|
| //--- Eventos
|
| static void OnNewDay(const datetime& curr_time);
|
| static void OnNewWeek(const datetime& curr_time);
|
| static void OnNewMonth(const datetime& curr_time);
|
| };
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::RemoveFromArrayFast(CAllClassEventsBasic* &array[], int &size, CAllClassEventsBasic* &ptr)
|
| {
|
| for(int i = 0; i < size; i++)
|
| {
|
| if(array[i] == ptr)
|
| {
|
| array[i] = array[size - 1];
|
| ArrayResize(array, --size);
|
| return;
|
| }
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::Unregister(CAllClassEventsBasic* ptr, const uint8_t flags)
|
| {
|
| if(!CheckPointer(ptr))
|
| {
|
| FastLog(FUNCION_ACTUAL, WARNING_TEXT, "Invalid pointer for unregister");
|
| return;
|
| }
|
|
|
| //--- OnNewDay
|
| if((flags & BASICEVENT_REG_FLAG_ON_NEW_DAY) != 0)
|
| RemoveFromArrayFast(m_on_new_day, m_on_new_day_size, ptr);
|
|
|
| //--- OnNewWeek
|
| if((flags & BASICEVENT_REG_FLAG_ON_NEW_WEEK) != 0)
|
| RemoveFromArrayFast(m_on_new_week, m_on_new_week_size, ptr);
|
|
|
| //--- OnNewMonth
|
| if((flags & BASICEVENT_REG_FLAG_ON_NEW_MON) != 0)
|
| RemoveFromArrayFast(m_on_new_mon, m_on_new_mon_size, ptr);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::UnregisterEvent(CAllClassEventsBasic *ptr, const uchar event)
|
| {
|
| if(!CheckPointer(ptr))
|
| {
|
| FastLog(FUNCION_ACTUAL, WARNING_TEXT, "Invalid pointer for unregister");
|
| return;
|
| }
|
|
|
| //--- OnNewDay
|
| if(event == BASICEVENT_REG_FLAG_ON_NEW_DAY)
|
| RemoveFromArrayFast(m_on_new_day, m_on_new_day_size, ptr);
|
|
|
| //--- OnNewWeek
|
| else
|
| if(event == BASICEVENT_REG_FLAG_ON_NEW_WEEK)
|
| RemoveFromArrayFast(m_on_new_week, m_on_new_week_size, ptr);
|
| //--- OnNewMonth
|
| else
|
| if(event == BASICEVENT_REG_FLAG_ON_NEW_MON)
|
| RemoveFromArrayFast(m_on_new_mon, m_on_new_mon_size, ptr);
|
|
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::RegisterEvent(CAllClassEventsBasic *ptr, const uchar event)
|
| {
|
| //---
|
| if(!CheckPointer(ptr))
|
| {
|
| FastLog(FUNCION_ACTUAL, FATAL_ERROR_TEXT, "No se puede registrar puntos invalidos");
|
| Remover();
|
| return;
|
| }
|
|
|
| //---
|
| if(event == BASICEVENT_REG_FLAG_ON_NEW_DAY)
|
| {
|
| m_on_new_day[ArrayResize(m_on_new_day, (++m_on_new_day_size)) - 1 ] = ptr;
|
| }
|
| //---
|
| else
|
| if(event == BASICEVENT_REG_FLAG_ON_NEW_WEEK)
|
| {
|
| m_on_new_week[ArrayResize(m_on_new_week, (++m_on_new_week_size)) - 1 ] = ptr;
|
| }
|
| //---
|
| else
|
| if(event == BASICEVENT_REG_FLAG_ON_NEW_MON)
|
| {
|
| m_on_new_mon[ArrayResize(m_on_new_mon, (++m_on_new_mon_size)) - 1 ] = ptr;
|
| }
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::Register(CAllClassEventsBasic *ptr, const uint8_t flags)
|
| {
|
| //---
|
| if(!CheckPointer(ptr))
|
| {
|
| FastLog(FUNCION_ACTUAL, FATAL_ERROR_TEXT, "No se puede registrar puntos invalidos");
|
| Remover();
|
| return;
|
| }
|
|
|
| //---
|
| if((flags & BASICEVENT_REG_FLAG_ON_NEW_DAY) != 0)
|
| {
|
| m_on_new_day[ArrayResize(m_on_new_day, (++m_on_new_day_size)) - 1 ] = ptr;
|
| }
|
|
|
| //---
|
| if((flags & BASICEVENT_REG_FLAG_ON_NEW_WEEK) != 0)
|
| {
|
| m_on_new_week[ArrayResize(m_on_new_week, (++m_on_new_week_size)) - 1 ] = ptr;
|
| }
|
|
|
| //---
|
| if((flags & BASICEVENT_REG_FLAG_ON_NEW_MON) != 0)
|
| {
|
| m_on_new_mon[ArrayResize(m_on_new_mon, (++m_on_new_mon_size)) - 1 ] = ptr;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::OnNewDay(const datetime& curr_time)
|
| {
|
| for(int i = 0; i < m_on_new_day_size; i++)
|
| {
|
| m_on_new_day[i].OnNewDay(curr_time);
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::OnNewWeek(const datetime &curr_time)
|
| {
|
| for(int i = 0; i < m_on_new_week_size; i++)
|
| {
|
| m_on_new_week[i].OnNewWeek(curr_time);
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| static void CBasicEvents::OnNewMonth(const datetime &curr_time)
|
| {
|
| for(int i = 0; i < m_on_new_mon_size; i++)
|
| {
|
| m_on_new_mon[i].OnNewMonth(curr_time);
|
| }
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| CAllClassEventsBasic* CBasicEvents::m_on_new_day[] = {};
|
| int CBasicEvents::m_on_new_day_size = 0;
|
| //---
|
| CAllClassEventsBasic* CBasicEvents::m_on_new_week[] = {};
|
| int CBasicEvents::m_on_new_week_size = 0;
|
| //---
|
| CAllClassEventsBasic*CBasicEvents:: m_on_new_mon[] = {};
|
| int CBasicEvents::m_on_new_mon_size = 0;
|
|
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| /* ---------- Experts
|
| //+------------------------------------------------------------------+
|
| //| Expert initialization function |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| //---
|
|
|
| //---
|
| return(INIT_SUCCEEDED);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Expert deinitialization function |
|
| //+------------------------------------------------------------------+
|
| void OnDeinit(const int reason)
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Expert tick function |
|
| //+------------------------------------------------------------------+
|
| void OnTick()
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Timer function |
|
| //+------------------------------------------------------------------+
|
| void OnTimer()
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Trade function |
|
| //+------------------------------------------------------------------+
|
| void OnTrade()
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| TradeTransaction function |
|
| //+------------------------------------------------------------------+
|
| void OnTradeTransaction(const MqlTradeTransaction& trans,
|
| const MqlTradeRequest& request,
|
| const MqlTradeResult& result)
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Tester function |
|
| //+------------------------------------------------------------------+
|
| double OnTester()
|
| {
|
| //---
|
| double ret=0.0;
|
| //---
|
|
|
| //---
|
| return(ret);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| TesterInit function |
|
| //+------------------------------------------------------------------+
|
| void OnTesterInit()
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| TesterPass function |
|
| //+------------------------------------------------------------------+
|
| void OnTesterPass()
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| TesterDeinit function |
|
| //+------------------------------------------------------------------+
|
| void OnTesterDeinit()
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| ChartEvent function |
|
| //+------------------------------------------------------------------+
|
| void OnChartEvent(const int id,
|
| const long &lparam,
|
| const double &dparam,
|
| const string &sparam)
|
| {
|
| //---
|
|
|
| }
|
| //+------------------------------------------------------------------+
|
| //| BookEvent function |
|
| //+------------------------------------------------------------------+
|
| void OnBookEvent(const string &symbol)
|
| {
|
| //---
|
|
|
| }
|
|
|
| ---
|
| [L1, L2, L3, L4]
|
| [0, 2, 3]
|
|
|
| ---
|
| Eliminar L3
|
| - [L1, L2, L4]
|
| Eliminar indice 2
|
| - [0, 3]
|
|
|
|
|
|
|
| */
|
| //+------------------------------------------------------------------+
|
| #endif // MQLARTICLES_UTILS_FA_EVENTS_MQH
|