MQLArticles/Utils/FA/Events.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                                       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:

  //--- Impidimos la instanciacion solo ptr.. pero se debe de asignar..

                     CAllClassEventsBasic() {}      

public:

                    ~CAllClassEventsBasic() {}



  //--- 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) {}

 };





//+------------------------------------------------------------------+

//| 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 bool        m_free;

  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        Deinit(const int& reason);



  //---

 static __forceinline bool IsActive() { return !m_free; }

 };





//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

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;

   }