MQLArticles/Utils/FA/ClasesBases.mqh

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

//|                                                  ClasesBases.mqh |

//|                                  Copyright 2025, Niquel Mendoza. |

//|                                             https://www.mql5.com |

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

#property copyright "Copyright 2025, Niquel Mendoza."

#property link      "https://www.mql5.com"

#property strict



#ifndef MQLARTICLES_UTILS_FA_CLASESBASES_MQH

#define MQLARTICLES_UTILS_FA_CLASESBASES_MQH



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

//| Includes                                                         |

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

//--- (CManagerBase | CSpecializedManager)

#include "Managers.mqh"



//--- (CBarControler | CBarControlerFast | CAtr | CAtrOptimized | CAtrOptimizedZero | CAtrOptimizedNonZero | CAtrUltraOptimized)

#include "Atr.mqh"



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

//| Clase CDiff - Defines                                            |

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

enum ENUM_MODE_DIFF

 {

  MODE_DIFF_BY_FIXED_POITNS, // By Points

  MODE_DIFF_BY_ATR           // By Atr

 };





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

//| Class CDiff - Difference calculation based on ATR or fixed points       |

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

/*

ESP:

Para usar la clase, solo se puede setear una vez..

1. llame y configure el modo SetMode

2. Luego condigura SetAtr y SetMode



Nota: El atr, ya debera de copiar los datos que luego seran accedios por esta clase, la clase unicamente calcula la

diferencia.



ENG:



To use the class, you can only set it once.

1. Call and set the SetMode mode.

2. Then set SetAtr and SetMode.



Note: The atr should already copy the data that will later be accessed by this class, the class only calculates the difference.

*/



//---

class CDiff : public CLoggerBase

 {

private:

  //---

  int                idx;           // Index for ATR

  string             symbol;        // Symbol for point calculation

  double             diff;          // Calculated difference value

  ENUM_MODE_DIFF     mode_diff;     // Difference calculation mode

  double             mul;           // Multiplier for ATR

  CAtr*              atr;           // Pointer to ATR object

  bool               is_atr;        // Flag to indicate if ATR is used

  

  //---

  bool               set_atr;

  bool               set_point;



public:

                     CDiff();

                     CDiff(const CDiff & diff_);

                    ~CDiff() {}



  //--- Configuration methods

  void               SetMode(ENUM_MODE_DIFF mode_diff_);

  void               SetAtr(CAtr * atr_, int idx_, double mul_);

  void               SetPoint(string symbol_, int min_diff_points_);



  //--- Method to update on new candle

  __forceinline void OnNewBar() { if(is_atr) diff = mul * atr[idx]; }



  //---

  inline bool        AtrIsActivate()  const { return is_atr;    }

  inline ENUM_MODE_DIFF GetTypeDiff() const { return mode_diff; }

  inline double      AtrMul() const { return mul; }

  void               AtrMul(double new_value);

  inline CAtr*       GetAtrPointer() const { return atr; }

  inline void        SetNewDiffAtrValue(const int new_idx);

  inline void        DiffPoints(int new_diff_points) { this.diff = new_diff_points * SymbolInfoDouble(this.symbol, SYMBOL_POINT); }

  inline int         DiffPoints() const { return (int)(this.diff / SymbolInfoDouble(this.symbol, SYMBOL_POINT)); }

  inline double      Diff()       const { return diff;                                                           }

 };



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

//| Default constructor                                              |

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

CDiff::CDiff(void)

  : idx(0), set_atr(false), set_point(false), diff(0.00), mul(1.00), atr(NULL), is_atr(false)

 {

// Initialize with default values

 }



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

//| Copy constructor                                                 |

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

CDiff::CDiff(const CDiff &diff_)

  : idx(diff_.idx),

    symbol(diff_.symbol),

    diff(diff_.diff),

    mode_diff(diff_.mode_diff),

    mul(diff_.mul),

    atr(diff_.atr),

    is_atr(diff_.is_atr),

    set_atr(diff_.set_atr),

    set_point(diff_.set_point)

 {

 }



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

//| Updates difference value based on ATR                            |

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

void CDiff::SetNewDiffAtrValue(const int new_idx)

 {

  if(!is_atr) //Only set diff if it's atr and valid

    return;

  this.diff = atr[new_idx] * mul;

 }



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

//| Sets the calculation mode                                        |

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

void CDiff::SetMode(ENUM_MODE_DIFF mode_diff_)

 {

//-- Don't allow changing mode if already configured

  if(set_atr || set_point) //If a mode has already been set then don't allow

    return;



  this.mode_diff = mode_diff_;

  this.is_atr = (mode_diff_ == MODE_DIFF_BY_ATR);

 }



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

//| Changes the ATR multiplier                                       |

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

void CDiff::AtrMul(double new_value)

 {

  if(!set_atr) //If atr hasn't been set, return

    return;



//--

  this.mul = new_value;



//--

  if(mul <= 0.00)

   {

    LogWarning(StringFormat("Invalid ATR multiplier ( %f ), switching to points mode", mul), __FUNCTION__);

    is_atr = false;

   }

  else

   {

    is_atr = true;

   }

 }



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

//| Configures calculation by points                                 |

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

void CDiff::SetPoint(string symbol_, int min_diff_points_)

 {

  if(mode_diff != MODE_DIFF_BY_FIXED_POITNS)

    return;



//--

  if(set_point) //Points have already been set

   {

    LogError("Points mode already configured. Use DiffPoints to change", __FUNCTION__);

    return;

   }



//--

  this.symbol = symbol_;

  set_point = true;



//--

  bool c;

  if(symbol_ == "" || !SymbolExist(symbol_, c))

   {

    LogFatalError(StringFormat("Invalid symbol in SetPoint: %s", symbol_), __FUNCTION__);

    this.diff = 0;

    Remover();

    return;

   }



//---

  this.diff = SymbolInfoDouble(this.symbol, SYMBOL_POINT) * min_diff_points_;

 }



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

//| Configures calculation by ATR                                    |

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

void CDiff::SetAtr(CAtr* atr_, int idx_, double mul_)

 {

  if(mode_diff != MODE_DIFF_BY_ATR)

    return; //If it's not atr then we exit



//--

  if(set_atr) //ATR has already been set

   {

    LogError("ATR mode already configured. Use AtrMul to change", __FUNCTION__);

    return;