Adwizard/Base/Factorable.mqh

//+------------------------------------------------------------------+
//|                                                   Factorable.mqh |
//|                                      Copyright 2024, Yuriy Bykov |
//|                            https://www.mql5.com/ru/users/antekov |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019-2024, Yuriy Bykov"
#property link      "https://www.mql5.com/ru/users/antekov"
#property version   "1.06"

#include "FactorableCreator.mqh"

// Объявление статического конструктора внутри класса
#define STATIC_CONSTRUCTOR(C) static CFactorable* Create(string p) { return new C(p); }

// Добавление статического конструктора для нового класса-наследника CFactorable
// в специальный массив через создание глобального объекта класса CFactorableCreator
#define REGISTER_FACTORABLE_CLASS(C) CFactorableCreator C##Creator(#C, C::Create);

// Создание объекта на фабрике из строки
#define NEW(P) CFactorable::Create(P)

// Создание дочернего объекта на фабрике из строки c проверкой.
// Вызывается только из конструктора текущего объекта.
// Если объект не создан, то текущий объект становится невалидным
// и осуществляется выход из конструктора
#define CREATE(C, O, P) C *O = NULL; if (IsValid()) { O = dynamic_cast<C*> (NEW(P)); if(!O) { SetInvalid(__FUNCTION__, StringFormat("Expected Object of class %s() at line %d in Params:\n%s", #C, __LINE__, P)); return; }}


//+------------------------------------------------------------------+
//| Базовый класс объектов, создаваемых из строки                    |
//+------------------------------------------------------------------+
class CFactorable {
private:
   bool              m_isValid;  // Объект исправный?

   // Очистка пустых символов слева и справа в строке инициализации
   static void       Trim(string &p_params);

   // Поиск парной закрывающей скобки в строке инициализации
   static int        FindCloseBracket(string &p_params, char closeBraket = ')');

   // Очистка строки инициализации с проверкой на исправность текущего объекта
   bool              CheckTrimParams(string &p_params);

protected:
   string            m_params;   // Строка инициализации текущего объекта
   bool              m_isActive; // Объект активен?

   // Установка текущего объекта в неисправное состояние
   void              SetInvalid(string function = NULL, string message = NULL);

public:
   CFactorable() :
      m_isValid(true),
      m_isActive(true) {}  // Конструктор

   bool              IsValid();                          // Объект исправный?
   bool              IsActive();                         // Объект активный?

   // Преобразование объекта в строку
   virtual string    operator~() = 0;

   // Строка инициалазации начинается с определения объекта?
   static bool       IsObject(string &p_params, const string className = "");

   // Строка инициалазации начинается с определения объекта нужного класса?
   static bool       IsObjectOf(string &p_params, const string className);

   // Чтение имени класса объекта из строки инициализации
   static string     ReadClassName(string &p_params, bool p_removeClassName = true);

   // Чтение объекта из строки инициализации
   string            ReadObject(string &p_params);

   // Чтение массива из строки инициализации в виде строки
   string            ReadArrayString(string &p_params);

   // Чтение строки из строки инициализации
   string            ReadString(string &p_params);

   // Чтение числа из строки инициализации в виде строки
   string            ReadNumber(string &p_params);

   // Чтение вещественного числа из строки инициализации
   double            ReadDouble(string &p_params);

   // Чтение целого числа из строки инициализации
   long              ReadLong(string &p_params);

   // Вычисление MD5-хеша строки
   static string     Hash(string p_params, string delimeter = "");
   virtual string    Hash() {
      return CFactorable::Hash(m_params);
   }

   // Создание объекта из строки инициализации
   static CFactorable* Create(string p_params);
};


//+------------------------------------------------------------------+
//| Очистка пустых символов слева и справа в строке инициализации    |
//+------------------------------------------------------------------+
void CFactorable::Trim(string &p_params) {
// Позиция слева, с которой начинается содержимое строки инициализации
   int posBeg = 0;

// Если в начале идёт одна запятая, то сдвигаемся вправо
   if(p_params[posBeg] == ',') posBeg++;

// Пока идут пробельные символы, сдвигаемся вправо
   while(false
         || p_params[posBeg] == '\r'
         || p_params[posBeg] == '\n'
         || p_params[posBeg] == '\t'
         || p_params[posBeg] == ' ') {
      posBeg++;
   }

// Если дальше идёт одна запятая, то ещё сдвигаемся вправо
   if(p_params[posBeg] == ',') posBeg++;

// Вырезаем незначащую левую часть строки инициализации
   p_params = StringSubstr(p_params, posBeg);

// Позиция справа, на которой заканчивается содержательная
// часть строки инициализации
   int posEnd = StringLen(p_params) - 1;

// Если в конце идёт одна запятая, то сдвигаемся влево
   if(p_params[posEnd] == ',') posEnd--;

// Пока идут пробельные символы, сдвигаемся влево
// но не дальше начала строки
   while(posEnd >= 0 && (false
                         || p_params[posEnd] == '\r'
                         || p_params[posEnd] == '\n'
                         || p_params[posEnd] == '\t'
                         || p_params[posEnd] == ' ')) {
      posEnd--;
   }

// Если дальше идёт одна запятая, то ещё сдвигаемся влево
   if(p_params[posEnd] == ',') posEnd--;

// Вырезаем незначащую правую часть строки инициализации
   p_params = StringSubstr(p_params, 0, posEnd + 1);
}

//+------------------------------------------------------------------+
//| Поиск парной закрывающей скобки в строке инициализации           |
//+------------------------------------------------------------------+
int CFactorable::FindCloseBracket(string &p_params, char closeBraket) {
// Cчётчик скобок
   int count = 0;
// Парная скобка
   char openBraket = (closeBraket == ')' ? '(' : '[');

// Находим первую открывающую скобку
   int pos;
   for(pos = 0; pos < StringLen(p_params); pos++) {
      if(p_params[pos] == openBraket) break;
   }

// Далее увеличиваем счётчик для открывающих и уменьшаем для закрывающих
   for(; pos < StringLen(p_params); pos++) {
      if(p_params[pos] == openBraket ) count++;
      if(p_params[pos] == closeBraket) count--;

      // Когда счётчик стал равен 0, то мы нашли парную закрывающую скобку
      if(count == 0) {
         return pos;
      }
   }
// Иначе скобка не найдена
   return -1;
}

//+------------------------------------------------------------------+
//| Очистка строки инициализации с проверкой на исправность          |
//| текущего объекта                                                 |
//+------------------------------------------------------------------+
bool CFactorable::CheckTrimParams(string &p_params) {
// Если текущий объект уже в неисправном состоянии, то вернуть false
   if(!IsValid()) return false;
// Очистим строку инициализации
   Trim(p_params);
// Вернём результат проверки, что строка инициализации не пустая
   return (p_params != NULL && p_params != "");
}

//+------------------------------------------------------------------+
//| Установка текущего объекта в неисправное состояние               |
//+------------------------------------------------------------------+
void CFactorable::SetInvalid(string function, string message) {
// Если объект ещё в исправном состоянии,
   if(IsValid()) {
      // то устанавливаем его в неисправное состояние
      m_isValid = false;
      if(function != NULL) {
         // Сообщаем об ошибке, если переданно имя вызывающей функции
         PrintFormat("%s | ERROR: %s", function, message);
      }
   } else {
      // Иначе просто сообщаем об ошибке, если переданно имя вызывающей функции
      if(function != NULL) {
         PrintFormat("%s | ERROR: Object is invalid already", function);
      }
   }
}

//+------------------------------------------------------------------+
//|  Объект исправный?                                               |
//+------------------------------------------------------------------+
bool CFactorable::IsValid() {
   return m_isValid;
}

//+------------------------------------------------------------------+
//|  Объект активный?                                               |
//+------------------------------------------------------------------+
bool CFactorable::IsActive() {
   return m_isActive;
}

//+------------------------------------------------------------------+
//| Строка инициалазации начинается с определения объекта?           |
//+------------------------------------------------------------------+
bool CFactorable::IsObject(string &p_params, const string className = "") {
// Возвращаем результат проверки, что в начале идет слово 'class'
// с возможным именем класса после одного пробела
   Trim(p_params);
   return (StringFind(p_params, "class " + className) == 0);
}

//+------------------------------------------------------------------+
//| Строка инициалазации начинается с определения объекта            |
//| нужного класса?                                                  |
//+------------------------------------------------------------------+
bool CFactorable::IsObjectOf(string &p_params, const string className) {
   return IsObject(p_params, className);
}

//+------------------------------------------------------------------+
//| Чтение имени класса объекта из строки инициализации              |
//+------------------------------------------------------------------+
string CFactorable::ReadClassName(string &p_params,
                                  bool p_removeClassName = true) {
// Очищаем пустые символы в начале и конце
   Trim(p_params);

// Если строка инициализации пустая, то ничего не делаем
   if(p_params == NULL || p_params == "") {
      return NULL;
   }

   string res = NULL;
// Начальная позиция - длина слова 'class '
   int posBeg = 6;
// Конечная позиция - открывающая скобка после имени класса
   int posEnd = StringFind(p_params, "(");

// Если в строке есть имя класса и параметры в скобках
   if(IsObject(p_params) && posEnd != -1) {
      // Вырезаем имя класса в качестве результата
      res = StringSubstr(p_params, posBeg, posEnd - posBeg);
      // Если в строке инициализации надо оставить только параметры, то
      if(p_removeClassName) {
         // Убираем из строки инициализации имя класса со скобками
         p_params = StringSubstr(p_params, posEnd + 1, StringLen(p_params) - posEnd - 2);
      }
   }
// Возвращаем результат
   return res;
}


//+------------------------------------------------------------------+
//| Чтение объекта из строки инициализации                           |
//+------------------------------------------------------------------+
string CFactorable::ReadObject(string &p_params) {
// Если строка инициализации не пустая и текущий объект ещё в исправном состоянии
   if(CheckTrimParams(p_params)) {
      // Если строка инициализации содержит описание объекта
      if(IsObject(p_params)) {
         // Находим положение скобки, закрывающей описание параметров объекта
         int posEnd = FindCloseBracket(p_params, ')');
         if(posEnd != -1) {
            // Всё до этой скобки включительно берём в качестве результата
            string res = StringSubstr(p_params, 0, posEnd + 1);
            // Убираем возвращаемую часть из строки инициализации
            p_params = StringSubstr(p_params, posEnd + 1);
            if(p_params == "") p_params = NULL;
            // Возвращаем результат
            return res;
         }
      }
   }
// Иначе устанавливаем текущий объект в неисправное состояние и сообщаем об ошибке
   SetInvalid(__FUNCTION__, StringFormat("Expected Object in Params:\n%s", p_params));

   return NULL;
}

//+------------------------------------------------------------------+
//| Чтение массива из строки инициализации в виде строки             |
//+------------------------------------------------------------------+
string CFactorable::ReadArrayString(string &p_params) {
// Если строка инициализации не пустая и текущий объект ещё в исправном состоянии
   if(CheckTrimParams(p_params)) {
      // Позиция конца описания массива
      int posEnd = -1;

      // Если в начале идёт открвающая массив скобка, то
      if(p_params[0] == '[') {
         // Находим позицию закрывающей скобки
         posEnd = FindCloseBracket(p_params, ']');
         // Если нашли, то
         if(posEnd != -1) {
            // Всё до этой скобки не доходя берём в качестве результата
            string res = StringSubstr(p_params, 1, posEnd - 1);
            // Очищаем пустые символы в начале и конце
            Trim(res);
            if(res == "") res = NULL;

            // Убираем возвращаемую часть вместе со скобкой из строки инициализации
            p_params = StringSubstr(p_params, posEnd + 1);
            if(p_params == "") p_params = NULL;

            // Возвращаем результат
            return res;
         }
      }
   }
// Иначе устанавливаем текущий объект в неисправное состояние и сообщаем об ошибке
   SetInvalid(__FUNCTION__, StringFormat("Expected Array in Params:\n%s", p_params));

   return NULL;
}

//+------------------------------------------------------------------+
//| Чтение строки из строки инициализации                            |
//+------------------------------------------------------------------+
string CFactorable::ReadString(string &p_params) {
// Если строка инициализации не пустая и текущий объект ещё в исправном состоянии
   if(CheckTrimParams(p_params)) {
      // Если это не описание массива и не описание объекта
      if(p_params[0] != '[' && !IsObject(p_params)) {
         // Позиция окончания читаемой строки
         int posEnd = -1;
         // Строка идет в кавычках?
         int quoted = (p_params[0] == '"' ? 1 : 0);

         // Если в кавычках, то
         if(quoted) {
            // Находим следующий символ кавычек
            posEnd = StringFind(p_params, "\"", 1);
            // Если не найден, то устанавливаем текущий объект в неисправное состояние с сообщением об ошибке
            if(posEnd == -1) {
               SetInvalid(__FUNCTION__, StringFormat("Closed quote not found in Params:\n%s", p_params));
               return NULL;
            }
            // Отступаем влево от закрывающей кавычки
            posEnd--;
         } else {
            // Иначе находим первую следующую запятую
            posEnd = StringFind(p_params, ",");
         }
         // Всё между двумя найденными позициями берём в качестве результата
         string res = StringSubstr(p_params, 0 + quoted, posEnd);
         // Убираем возвращаемую часть вместе с кавычками из строки инициализации
         p_params = StringSubstr(p_params, posEnd + quoted + 1);
         if(p_params == "") {
            p_params = NULL;
         }
         // Возвращаем результат
         return res;
      }
   }

// Иначе устанавливаем текущий объект в неисправное состояние и сообщаем об ошибке
   SetInvalid(__FUNCTION__, StringFormat("Expected String in Params:\n%s", p_params));

   return NULL;
}

//+------------------------------------------------------------------+
//| Чтение числа из строки инициализации в виде строки               |
//+------------------------------------------------------------------+
string CFactorable::ReadNumber(string &p_params) {
// Если строка инициализации не пустая и текущий объект ещё в исправном состоянии
   if(CheckTrimParams(p_params)) {
      // Если это не описание массива, не описание строки и не описание объекта
      if(p_params[0] != '['
            && p_params[0] != '"'
            && !IsObject(p_params)) {
         // Находим позицию окончания читаемого числа по следующей запятой
         int posEnd = StringFind(p_params, ",");
         // Всё от начала до найденной позиции берём в качестве результата
         string res = StringSubstr(p_params, 0, posEnd);
         // Убираем возвращаемую часть из строки инициализации
         p_params = StringSubstr(p_params, posEnd + 1);
         if(posEnd == -1) {
            p_params = NULL;
         }
         // Возвращаем результат
         return res;
      }
   }

// Иначе устанавливаем текущий объект в неисправное состояние и сообщаем об ошибке
   SetInvalid(__FUNCTION__, StringFormat("Expected Number in Params:\n%s", p_params));

   return NULL;
}

//+------------------------------------------------------------------+
//| Чтение вещественного числа из строки инициализации               |
//+------------------------------------------------------------------+
double CFactorable::ReadDouble(string &p_params) {
   return StringToDouble(ReadNumber(p_params));
}

//+------------------------------------------------------------------+
//| Чтение целого числа из строки инициализации                      |
//+------------------------------------------------------------------+
long CFactorable::ReadLong(string &p_params) {
   return StringToInteger(ReadNumber(p_params));
}

//+------------------------------------------------------------------+
//| Вычисление MD5-хеша строки                                       |
//+------------------------------------------------------------------+
string CFactorable::Hash(string p_params, string p_delimeter = "") {
   uchar hash[], key[], data[];

// Вычисляем хеш от строки инициализации
   StringToCharArray(p_params, data);
   CryptEncode(CRYPT_HASH_MD5, data, key, hash);

// Переводим его из массива чисел в строку с шестнадцатеричной записью
   string res = "";
   FOREACH(hash) {
      res += StringFormat("%X", hash[i]);
      if(i % 4 == 3 && i < 15) res += p_delimeter;
   }

   return res;
}

//+------------------------------------------------------------------+
//| Создание объекта из строки инициализации                         |
//+------------------------------------------------------------------+
CFactorable* CFactorable::Create(string p_params) {
// Указатель на создаваемый объект
   CFactorable* object = NULL;

// Читаем имя класса объекта
   string className = CFactorable::ReadClassName(p_params);

// В зависимости от имени класса находим и вызываем соответствующий конструктор
   int i;
   SEARCH(CFactorableCreator::creators, className == CFactorableCreator::creators[i].m_className, i);
   if(i != -1) {
      object = CFactorableCreator::creators[i].m_creator(p_params);
   }

// Если объект не создан или создан в неисправном состоянии, то сообщаем об ошибке
   if(!object) {
      PrintFormat(__FUNCTION__" | ERROR: Constructor not found for:\n%s",
                  p_params);
   } else if(!object.IsValid()) {
      PrintFormat(__FUNCTION__
                  " | ERROR: Created object is invalid for:\n%s",
                  p_params);
      delete object; // Удаляем неисправный объект
      object = NULL;
   }

   return object;
}
//+------------------------------------------------------------------+