//+------------------------------------------------------------------+
//|                                                   ExpertBase.mqh |
//|                             Copyright 2000-2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Trade\SymbolInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Trade\HistoryOrderInfo.mqh>
#include <Indicators\Indicators.mqh>
//+------------------------------------------------------------------+
//| enumerations                                                     |
//+------------------------------------------------------------------+
//--- constants of identification of trend
enum ENUM_TYPE_TREND
  {
   TYPE_TREND_HARD_DOWN  =0,           // strong down trend
   TYPE_TREND_DOWN       =1,           // down trend
   TYPE_TREND_SOFT_DOWN  =2,           // weak down trend
   TYPE_TREND_FLAT       =3,           // no trend
   TYPE_TREND_SOFT_UP    =4,           // weak up trend
   TYPE_TREND_UP         =5,           // up trend
   TYPE_TREND_HARD_UP    =6            // strong up trend
  };
//--- flags of used timeseries
enum ENUM_USED_SERIES
  {
   USE_SERIES_OPEN       =0x1,
   USE_SERIES_HIGH       =0x2,
   USE_SERIES_LOW        =0x4,
   USE_SERIES_CLOSE      =0x8,
   USE_SERIES_SPREAD     =0x10,
   USE_SERIES_TIME       =0x20,
   USE_SERIES_TICK_VOLUME=0x40,
   USE_SERIES_REAL_VOLUME=0x80
  };
//--- phases of initialization of an object
enum ENUM_INIT_PHASE
  {
   INIT_PHASE_FIRST      =0,           // start phase (only Init(...) can be called)
   INIT_PHASE_TUNING     =1,           // phase of tuning (set in Init(...))
   INIT_PHASE_VALIDATION =2,           // phase of checking of parameters(set in ValidationSettings(...))
   INIT_PHASE_COMPLETE   =3            // end phase (set in InitIndicators(...))
  };
//+------------------------------------------------------------------+
//| Macro definitions.                                               |
//+------------------------------------------------------------------+
//--- check the use of timeseries
#define IS_OPEN_SERIES_USAGE         ((m_used_series&USE_SERIES_OPEN)!=0)
#define IS_HIGH_SERIES_USAGE         ((m_used_series&USE_SERIES_HIGH)!=0)
#define IS_LOW_SERIES_USAGE          ((m_used_series&USE_SERIES_LOW)!=0)
#define IS_CLOSE_SERIES_USAGE        ((m_used_series&USE_SERIES_CLOSE)!=0)
#define IS_SPREAD_SERIES_USAGE       ((m_used_series&USE_SERIES_SPREAD)!=0)
#define IS_TIME_SERIES_USAGE         ((m_used_series&USE_SERIES_TIME)!=0)
#define IS_TICK_VOLUME_SERIES_USAGE  ((m_used_series&USE_SERIES_TICK_VOLUME)!=0)
#define IS_REAL_VOLUME_SERIES_USAGE  ((m_used_series&USE_SERIES_REAL_VOLUME)!=0)
//+------------------------------------------------------------------+
//| Class CExpertBase.                                               |
//| Purpose: Base class of component of Expert Advisor.              |
//| Derives from class CObject.                                      |
//+------------------------------------------------------------------+
class CExpertBase : public CObject
  {
protected:
   //--- variables
   ulong             m_magic;          // expert magic number
   ENUM_INIT_PHASE   m_init_phase;     // the phase (stage) of initialization of object
   bool              m_other_symbol;   // flag of a custom work symbols (different from one of the Expert Advisor)
   CSymbolInfo      *m_symbol;         // pointer to the object-symbol
   bool              m_other_period;   // flag of a custom timeframe (different from one of the Expert Advisor)
   ENUM_TIMEFRAMES   m_period;         // work timeframe
   double            m_adjusted_point; // "weight" 2/4 of a point
   CAccountInfo      m_account;        // object-deposit
   ENUM_ACCOUNT_MARGIN_MODE m_margin_mode; // netting or hedging
   ENUM_TYPE_TREND   m_trend_type;     // identifier of trend
   bool              m_every_tick;     // flag of starting the analysis from current (incomplete) bar
   //--- timeseries
   int               m_used_series;    // flags of using of series
   CiOpen           *m_open;           // pointer to the object for access to open prices of bars
   CiHigh           *m_high;           // pointer to the object for access to high prices of bars
   CiLow            *m_low;            // pointer to the object for access to low prices of bars
   CiClose          *m_close;          // pointer to the object for access to close prices of bars
   CiSpread         *m_spread;         // pointer to the object for access to spreads
   CiTime           *m_time;           // pointer to the object for access to time of closing of bars
   CiTickVolume     *m_tick_volume;    // pointer to the object for access to tick volumes of bars
   CiRealVolume     *m_real_volume;    // pointer to the object for access to real volumes of bars

public:
                     CExpertBase(void);
                    ~CExpertBase(void);
   //--- methods of access to protected data
   ENUM_INIT_PHASE   InitPhase(void)            const { return(m_init_phase); }
   void              TrendType(ENUM_TYPE_TREND value) { m_trend_type=value;   }
   int               UsedSeries(void) const;
   void              EveryTick(bool value)            { m_every_tick=value;   }
   //--- methods of access to protected data
   double            Open(int ind) const;
   double            High(int ind) const;
   double            Low(int ind) const;
   double            Close(int ind) const;
   int               Spread(int ind) const;
   datetime          Time(int ind) const;
   long              TickVolume(int ind) const;
   long              RealVolume(int ind) const;
   //--- methods of initialization of the object
   virtual bool      Init(CSymbolInfo *symbol,ENUM_TIMEFRAMES period,double point);
   bool              Symbol(string name);
   bool              Period(ENUM_TIMEFRAMES value);
   void              Magic(ulong value) { m_magic=value; }
   void              SetMarginMode(void) { m_margin_mode=(ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE); }
   //--- method of verification of settings
   virtual bool      ValidationSettings();
   //--- methods of creating the indicator and timeseries
   virtual bool      SetPriceSeries(CiOpen *open,CiHigh *high,CiLow *low,CiClose *close);
   virtual bool      SetOtherSeries(CiSpread *spread,CiTime *time,CiTickVolume *tick_volume,CiRealVolume *real_volume);
   virtual bool      InitIndicators(CIndicators *indicators=NULL);

protected:
   //--- methods initialization of timeseries
   bool              InitOpen(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   bool              InitSpread(CIndicators *indicators);
   bool              InitTime(CIndicators *indicators);
   bool              InitTickVolume(CIndicators *indicators);
   bool              InitRealVolume(CIndicators *indicators);
   //--- method of getting the measure units of price levels
   virtual double    PriceLevelUnit(void)      { return(m_adjusted_point); }
   //--- method of getting index of bar the analysis starts with
   virtual int       StartIndex(void) { return((m_every_tick?0:1)); }
   virtual bool      CompareMagic(ulong magic) { return(m_magic==magic);   }
   bool              IsHedging(void) const { return(m_margin_mode==ACCOUNT_MARGIN_MODE_RETAIL_HEDGING); }
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
void CExpertBase::CExpertBase(void) : m_magic(0),
                                      m_margin_mode(ACCOUNT_MARGIN_MODE_RETAIL_NETTING),
                                      m_init_phase(INIT_PHASE_FIRST),
                                      m_other_symbol(false),
                                      m_symbol(NULL),
                                      m_other_period(false),
                                      m_period(PERIOD_CURRENT),
                                      m_adjusted_point(1.0),
                                      m_trend_type(TYPE_TREND_FLAT),
                                      m_every_tick(false),
                                      m_used_series(0),
                                      m_open(NULL),
                                      m_high(NULL),
                                      m_low(NULL),
                                      m_close(NULL),
                                      m_spread(NULL),
                                      m_time(NULL),
                                      m_tick_volume(NULL),
                                      m_real_volume(NULL)

  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
void CExpertBase::~CExpertBase(void)
  {
//--- if the symbol is "custom", delete it
   if(m_other_symbol && m_symbol!=NULL)
      delete m_symbol;
//--- release of "custom" timeseries
   if(m_other_symbol || m_other_period)
     {
      if(IS_OPEN_SERIES_USAGE && CheckPointer(m_open)==POINTER_DYNAMIC)
         delete m_open;
      if(IS_HIGH_SERIES_USAGE && CheckPointer(m_high)==POINTER_DYNAMIC)
         delete m_high;
      if(IS_LOW_SERIES_USAGE && CheckPointer(m_low)==POINTER_DYNAMIC)
         delete m_low;
      if(IS_CLOSE_SERIES_USAGE && CheckPointer(m_close)==POINTER_DYNAMIC)
         delete m_close;
      if(IS_SPREAD_SERIES_USAGE && CheckPointer(m_spread)==POINTER_DYNAMIC)
         delete m_spread;
      if(IS_TIME_SERIES_USAGE && CheckPointer(m_time)==POINTER_DYNAMIC)
         delete m_time;
      if(IS_TICK_VOLUME_SERIES_USAGE && CheckPointer(m_tick_volume)==POINTER_DYNAMIC)
         delete m_tick_volume;
      if(IS_REAL_VOLUME_SERIES_USAGE && CheckPointer(m_real_volume)==POINTER_DYNAMIC)
         delete m_real_volume;
     }
  }
//+------------------------------------------------------------------+
//| Get flags of used timeseries                                     |
//+------------------------------------------------------------------+
int CExpertBase::UsedSeries(void) const
  {
   if(m_other_symbol || m_other_period)
      return(0);
//---
   return(m_used_series);
  }
//+------------------------------------------------------------------+
//| Initialization of object.                                        |
//+------------------------------------------------------------------+
bool CExpertBase::Init(CSymbolInfo *symbol,ENUM_TIMEFRAMES period,double point)
  {
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_FIRST)
     {
      Print(__FUNCTION__+": attempt of re-initialization");
      return(false);
     }
//--- check of pointer
   if(symbol==NULL)
     {
      Print(__FUNCTION__+": error initialization");
      return(false);
     }
//--- initialization
   m_symbol        =symbol;
   m_period        =period;
   m_adjusted_point=point;
   m_other_symbol  =false;
   m_other_period  =false;
   SetMarginMode();
//--- primary initialization is successful, pass to the phase of tuning
   m_init_phase=INIT_PHASE_TUNING;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Changing work symbol.                                            |
//+------------------------------------------------------------------+
bool CExpertBase::Symbol(string name)
  {
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_TUNING)
     {
      Print(__FUNCTION__+": changing of symbol is forbidden");
      return(false);
     }
   if(m_symbol!=NULL)
     {
      //--- symbol has been already set
      if(m_symbol.Name()==name)
         return(true);
      //--- symbol is not the one required, but is already "custom"
      if(m_other_symbol)
        {
         if(!m_symbol.Name(name))
           {
            //--- failed to initialize the symbol
            delete m_symbol;
            return(false);
           }
         return(true);
        }
     }
   m_symbol=new CSymbolInfo;
//--- check of pointer
   if(m_symbol==NULL)
     {
      Print(__FUNCTION__+": error of changing of symbol");
      return(false);
     }
   if(!m_symbol.Name(name))
     {
      //--- failed to initialize the symbol
      delete m_symbol;
      return(false);
     }
   m_other_symbol=true;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Changing work timeframe.                                         |
//+------------------------------------------------------------------+
bool CExpertBase::Period(ENUM_TIMEFRAMES value)
  {
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_TUNING)
     {
      Print(__FUNCTION__+": changing of timeframe is forbidden");
      return(false);
     }
   if(m_period==value)
      return(true);
//--- change work timeframe
   m_period=value;
   m_other_period=true;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Checking adjustable parameters                                   |
//+------------------------------------------------------------------+
bool CExpertBase::ValidationSettings()
  {
//--- rechecking parameters
   if(m_init_phase==INIT_PHASE_VALIDATION)
      return(true);
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_TUNING)
     {
      Print(__FUNCTION__+": not the right time to check parameters");
      return(false);
     }
//--- initial check of parameters is successful, phase of tuning is over
   m_init_phase=INIT_PHASE_VALIDATION;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Setting pointers of price timeseries.                            |
//+------------------------------------------------------------------+
bool CExpertBase::SetPriceSeries(CiOpen *open,CiHigh *high,CiLow *low,CiClose *close)
  {
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_VALIDATION)
     {
      Print(__FUNCTION__+": changing of timeseries is forbidden");
      return(false);
     }
//--- check pointers
   if((IS_OPEN_SERIES_USAGE  && open==NULL) ||
      (IS_HIGH_SERIES_USAGE  && high==NULL) ||
      (IS_LOW_SERIES_USAGE   && low==NULL)  || 
      (IS_CLOSE_SERIES_USAGE && close==NULL))
     {
      Print(__FUNCTION__+": NULL pointer");
      return(false);
     }
   m_open =open;
   m_high =high;
   m_low  =low;
   m_close=close;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Setting pointers of other timeseries.                            |
//+------------------------------------------------------------------+
bool CExpertBase::SetOtherSeries(CiSpread *spread,CiTime *time,CiTickVolume *tick_volume,CiRealVolume *real_volume)
  {
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_VALIDATION)
     {
      Print(__FUNCTION__+": changing of timeseries is forbidden");
      return(false);
     }
//--- check pointers
   if((IS_SPREAD_SERIES_USAGE && spread==NULL) || 
      (IS_TIME_SERIES_USAGE && time==NULL) || 
      (IS_TICK_VOLUME_SERIES_USAGE && tick_volume==NULL) ||
      (IS_REAL_VOLUME_SERIES_USAGE && real_volume==NULL))
     {
      Print(__FUNCTION__+": NULL pointer");
      return(false);
     }
   m_spread     =spread;
   m_time       =time;
   m_tick_volume=tick_volume;
   m_real_volume=real_volume;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of indicators and timeseries.                     |
//+------------------------------------------------------------------+
bool CExpertBase::InitIndicators(CIndicators *indicators)
  {
//--- this call is for compatibility with the previous version
   if(!ValidationSettings())
      return(false);
//--- check the initialization phase
   if(m_init_phase!=INIT_PHASE_VALIDATION)
     {
      Print(__FUNCTION__+": parameters of setting are not checked");
      return(false);
     }
   if(!m_other_symbol && !m_other_period)
      return(true);
//--- check pointers
   if(m_symbol==NULL)
      return(false);
   if(indicators==NULL)
      return(false);
//--- initialization of required timeseries
   if(IS_OPEN_SERIES_USAGE && !InitOpen(indicators))
      return(false);
   if(IS_HIGH_SERIES_USAGE && !InitHigh(indicators))
      return(false);
   if(IS_LOW_SERIES_USAGE && !InitLow(indicators))
      return(false);
   if(IS_CLOSE_SERIES_USAGE && !InitClose(indicators))
      return(false);
   if(IS_SPREAD_SERIES_USAGE && !InitSpread(indicators))
      return(false);
   if(IS_TIME_SERIES_USAGE && !InitTime(indicators))
      return(false);
   if(IS_TICK_VOLUME_SERIES_USAGE && !InitTickVolume(indicators))
      return(false);
   if(IS_REAL_VOLUME_SERIES_USAGE && !InitRealVolume(indicators))
      return(false);
//--- initialization of object (from the point of view of the base class) has been performed successfully
//--- now it's impossible to change anything in the settings
   m_init_phase=INIT_PHASE_COMPLETE;
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Access to data of the Open timeseries.                           |
//+------------------------------------------------------------------+
double CExpertBase::Open(int ind) const
  {
//--- check pointer
   if(m_open==NULL)
      return(EMPTY_VALUE);
//--- return the result
   return(m_open.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the High timeseries.                           |
//+------------------------------------------------------------------+
double CExpertBase::High(int ind) const
  {
//--- check pointer
   if(m_high==NULL)
      return(EMPTY_VALUE);
//--- return the result
   return(m_high.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the Low timeseries.                            |
//+------------------------------------------------------------------+
double CExpertBase::Low(int ind) const
  {
//--- check pointer
   if(m_low==NULL)
      return(EMPTY_VALUE);
//--- return the result
   return(m_low.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the Close timeseries.                          |
//+------------------------------------------------------------------+
double CExpertBase::Close(int ind) const
  {
//--- check pointer
   if(m_close==NULL)
      return(EMPTY_VALUE);
//--- return the result
   return(m_close.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the Spread timeseries.                         |
//+------------------------------------------------------------------+
int CExpertBase::Spread(int ind) const
  {
//--- check pointer
   if(m_spread==NULL)
      return(INT_MAX);
//--- return the result
   return(m_spread.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the Time timeseries.                           |
//+------------------------------------------------------------------+
datetime CExpertBase::Time(int ind) const
  {
//--- check pointer
   if(m_time==NULL)
      return(0);
//--- return the result
   return(m_time.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the TickVolume timeseries.                     |
//+------------------------------------------------------------------+
long CExpertBase::TickVolume(int ind) const
  {
//--- check pointer
   if(m_tick_volume==NULL)
      return(0);
//--- return the result
   return(m_tick_volume.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Access to data of the RealVolume timeseries.                     |
//+------------------------------------------------------------------+
long CExpertBase::RealVolume(int ind) const
  {
//--- check pointer
   if(m_real_volume==NULL)
      return(0);
//--- return the result
   return(m_real_volume.GetData(ind));
  }
//+------------------------------------------------------------------+
//| Initialization of the Open timeseries.                           |
//+------------------------------------------------------------------+
bool CExpertBase::InitOpen(CIndicators *indicators)
  {
//--- create object
   if((m_open=new CiOpen)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_open))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_open;
      return(false);
     }
//--- initialize object
   if(!m_open.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the High timeseries.                           |
//+------------------------------------------------------------------+
bool CExpertBase::InitHigh(CIndicators *indicators)
  {
//--- create object
   if((m_high=new CiHigh)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_high))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_high;
      return(false);
     }
//--- initialize object
   if(!m_high.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the Low timeseries.                            |
//+------------------------------------------------------------------+
bool CExpertBase::InitLow(CIndicators *indicators)
  {
//--- create object
   if((m_low=new CiLow)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_low))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_low;
      return(false);
     }
//--- initialize object
   if(!m_low.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the Close timeseries.                          |
//+------------------------------------------------------------------+
bool CExpertBase::InitClose(CIndicators *indicators)
  {
//--- create object
   if((m_close=new CiClose)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_close))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_close;
      return(false);
     }
//--- initialize object
   if(!m_close.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the Spread timeseries.                         |
//+------------------------------------------------------------------+
bool CExpertBase::InitSpread(CIndicators *indicators)
  {
//--- create object
   if((m_spread=new CiSpread)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_spread))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_spread;
      return(false);
     }
//--- initialize object
   if(!m_spread.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the Time timeseries.                           |
//+------------------------------------------------------------------+
bool CExpertBase::InitTime(CIndicators *indicators)
  {
//--- create object
   if((m_time=new CiTime)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_time))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_time;
      return(false);
     }
//--- initialize object
   if(!m_time.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the TickVolume timeseries.                     |
//+------------------------------------------------------------------+
bool CExpertBase::InitTickVolume(CIndicators *indicators)
  {
//--- create object
   if((m_tick_volume=new CiTickVolume)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_tick_volume))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_tick_volume;
      return(false);
     }
//--- initialize object
   if(!m_tick_volume.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialization of the RealVolume timeseries.                     |
//+------------------------------------------------------------------+
bool CExpertBase::InitRealVolume(CIndicators *indicators)
  {
//--- create object
   if((m_real_volume=new CiRealVolume)==NULL)
     {
      Print(__FUNCTION__+": error creating object");
      return(false);
     }
//--- add object to collection
   if(!indicators.Add(m_real_volume))
     {
      Print(__FUNCTION__+": error adding object");
      delete m_real_volume;
      return(false);
     }
//--- initialize object
   if(!m_real_volume.Create(m_symbol.Name(),m_period))
     {
      Print(__FUNCTION__+": error initializing object");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
