| //+------------------------------------------------------------------+
|
| //| Main.mqh |
|
| //| Copyright 2025, Niquel Mendoza. |
|
| //| https://www.mql5.com/es/users/nique_372 |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, Niquel Mendoza."
|
| #property link "https://www.mql5.com/es/users/nique_372"
|
| #property strict
|
|
|
| #ifndef MQLARTICLES_UTILS_SETFILES_MAIN_MQH
|
| #define MQLARTICLES_UTILS_SETFILES_MAIN_MQH
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #include "..\\Basic.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| enum ENUM_SETFILE_LINE_TYPE
|
| {
|
| SETFILE_LINE_TYPE_NOINPUT = 1,
|
| SETFILE_LINE_TYPE_INPUT = 0
|
| };
|
|
|
| //---
|
| string g_setfile_dyn_arr[5];
|
|
|
| //---
|
| struct SetFileParam
|
| {
|
| string name;
|
| string value;
|
| string start;
|
| string step;
|
| string stop;
|
|
|
| //---
|
| SetFileParam()
|
| : value(NULL), start(NULL), step(NULL), stop(NULL)
|
| {
|
| }
|
|
|
| //---
|
| // si start == NULL signfiica que es invalido para optimizar
|
| __forceinline string Format() { return start != NULL ? StringFormat("%s=%s||%s||%s||%s||N", name, value, start, step, stop) : (name + "=" + value); }
|
| };
|
|
|
| //---
|
| struct pack(4) SetFileLine
|
| {
|
| ENUM_SETFILE_LINE_TYPE type;
|
| int id;
|
| };
|
|
|
| //---
|
| SetFileParam EMPTY_SETFILE_PARAM;
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| class CSetFile : public CLoggerBase
|
| {
|
| private:
|
| //---
|
| CHashMap<string, int>* m_hashmap_params;
|
| bool m_init;
|
|
|
| //--- Lines
|
| SetFileLine m_lines[];
|
| int m_lines_size;
|
|
|
| //--- Inputs
|
| int m_params_size;
|
| SetFileParam m_params[];
|
|
|
| //--- Strings
|
| int m_no_params_size;
|
| string m_no_params[];
|
|
|
| //--- Data
|
| string m_expert_name;
|
| datetime m_saved_time;
|
|
|
| //---
|
| void ChangeSavedTime(const datetime new_time);
|
|
|
|
|
| public:
|
| CSetFile(void);
|
| ~CSetFile(void);
|
|
|
| //---
|
| bool Init(const string& expert_name);
|
| bool InitByFile(const string& file_name, int extra_file_flags, uint reserve);
|
| bool InitBySrc(const string& src, ushort separator, uint reserve);
|
|
|
| //---
|
| bool Save(const string& file_name, int extra_file_flags);
|
|
|
| //---
|
| void Clean();
|
|
|
| //---
|
| void GetAsString(string &out) const;
|
| int GetAsStringArray(string& out[]) const;
|
|
|
| //---
|
| void Summary() const;
|
| void Imprimir() const;
|
| void ImprimirLinesArray() const { ArrayPrint(m_lines, 2, "|"); }
|
| void ImprimirParamsArray() const { ArrayPrint(m_params, 2, "|"); }
|
| void ImprimirNoParamsArray() const { ArrayPrint(m_no_params, 2, "|"); }
|
|
|
| //--- Getters \Setters
|
| __forceinline int ParamsSize() const { return m_params_size; }
|
| __forceinline SetFileParam GetParam(const int idx) const { return m_params[idx]; }
|
| __forceinline SetFileParam GetParam(const string str) const;
|
| __forceinline int GetParamIdx(const string str) const;
|
|
|
|
|
| __forceinline int NoParamsSize() const { return m_no_params_size; }
|
| __forceinline string GetNoParmas(const int idx) const { return m_no_params[idx]; }
|
|
|
| __forceinline int LinesSize() const { return m_lines_size; }
|
| __forceinline SetFileLine GetLine(const int idx) const { return m_lines[idx]; }
|
|
|
| // Expert name
|
| __forceinline string ExpertName() const { return m_expert_name; }
|
| void ExpertName(const string& v) { m_expert_name = v; }
|
|
|
| // Saved time
|
| __forceinline datetime SavedTime() const { return m_saved_time; }
|
|
|
| //--- Funciones para remover un alinea (idx indice en m_lines)
|
| bool RemoveLine(const int idx);
|
|
|
| //--- Funciones para trabajar con los parametros
|
| //- Agrega un parametro (al final) (por defecto start, etc es null osea que noe s optimizable si se espeicfia los 3 valores entonces si es optimzable)
|
| bool AddParamLineString(const string& name, const string& value);
|
|
|
| // Number
|
| template <typename TInteger>
|
| bool AddParamLineNumber(const string& name, const TInteger value, const TInteger start, const TInteger step, const TInteger stop);
|
|
|
| // Real
|
| template <typename TNumber>
|
| bool AddParamLineReal(const string& name, const TNumber value, int8_t presicion, const TNumber start, const TNumber step, const TNumber stop);
|
|
|
| // Bool
|
| bool AddParamLineBool(const string& name, const bool value);
|
|
|
| // Enum
|
| template <typename TEnum>
|
| bool AddParamLineEnum(const string& name, const TEnum value, const TEnum start, const TEnum stop);
|
|
|
| // Datetime
|
| bool AddParamLineDatetime(const string& name, const datetime value, const datetime start, const long step_sec, const datetime stop);
|
|
|
| // Color
|
| bool AddParamLineColor(const string& name, const color value);
|
|
|
|
|
| // Idx = indice del FILE
|
| //- Inserta
|
| bool InsertParamLineString(const int idx, const string& name, const string& value);
|
|
|
| template <typename TInteger>
|
| bool InsertParamLineNumber(const int idx, const string& name, const TInteger value, const TInteger start, const TInteger step, const TInteger stop);
|
|
|
| template <typename TNumber>
|
| bool InsertParamLineReal(const int idx, const string& name, const TNumber value, int8_t presicion, const TNumber start, const TNumber step, const TNumber stop);
|
|
|
| bool InsertParamLineBool(const int idx, const string& name, const bool value);
|
|
|
| template <typename TEnum>
|
| bool InsertParamLineEnum(const int idx, const string& name, const TEnum value, const TEnum start, const TEnum stop);
|
|
|
| bool InsertParamLineDatetime(const int idx, const string& name, const datetime value, const datetime start, const long step_sec, const datetime stop);
|
|
|
| bool InsertParamLineColor(const int idx, const string& name, const color value);
|
|
|
|
|
| //- Modificar
|
| // Nombre de parametro
|
| bool ModifyParamName(const string param_name, const string& new_name);
|
| bool ModifyParamName(const int idx, const string& new_name);
|
|
|
| // Valor de parametro (value)
|
| template <typename TInteger> // Todo tipo de numero integer uinteger | datetime | color
|
| bool ModifyParamValueNumber(const string param_name, const TInteger v);
|
| template <typename TNumber> // Double float
|
| bool ModifyParamValueRealNumber(const string param_name, const TNumber v, int8_t presicion);
|
| bool ModifyParamValueBoolean(const string param_name, const bool v);
|
| bool ModifyParamValueString(const string param_name, const string v);
|
| template <typename TEnum> // Double float
|
| bool ModifyParamValueEnum(const string param_name, const TEnum v);
|
| bool ModifyParamValueDatetime(const string param_name, const datetime v);
|
| bool ModifyParamValueColor(const string param_name, const color v);
|
|
|
|
|
| // ModifyParamOptNumber
|
| template <typename TInteger>
|
| bool ModifyParamOptNumberStart(const string param_name, const TInteger start);
|
| template <typename TInteger>
|
| bool ModifyParamOptNumberStep(const string param_name, const TInteger step);
|
| template <typename TInteger>
|
| bool ModifyParamOptNumberStop(const string param_name, const TInteger stop);
|
|
|
| // ModifyParamOptRealNumber
|
| template <typename TNumber>
|
| bool ModifyParamOptRealNumberStart(const string param_name, const TNumber start, int8_t presicion);
|
| template <typename TNumber>
|
| bool ModifyParamOptRealNumberStep(const string param_name, const TNumber step, int8_t presicion);
|
| template <typename TNumber>
|
| bool ModifyParamOptRealNumberStop(const string param_name, const TNumber stop, int8_t presicion);
|
|
|
|
|
| // Modify opt datetime
|
| bool ModifyParamOptDatetimeStart(const string param_name, const datetime start);
|
| bool ModifyParamOptDatetimeStep(const string param_name, const long step_sec);
|
| bool ModifyParamOptDatetimeStop(const string param_name, const datetime stop);
|
|
|
|
|
| // ModifyParamOptEnum
|
| template <typename TEnum>
|
| bool ModifyParamOptEnumStart(const string param_name, const TEnum start);
|
| template <typename TEnum>
|
| bool ModifyParamOptEnumStop(const string param_name, const TEnum stop);
|
|
|
| //- Verificar exisitencia
|
| bool ParamExist(const string& param_name) { return m_hashmap_params.ContainsKey(param_name); }
|
|
|
|
|
| //- Lectura
|
| string ReadParamValueString(const string param_name) const;
|
|
|
| template <typename TInteger>
|
| TInteger ReadParamValueInteger(const string param_name) const;
|
|
|
| template <typename TNumber>
|
| TNumber ReadParamValueReal(const string param_name) const;
|
|
|
| datetime ReadParamValueDatetime(const string param_name) const;
|
| color ReadParamValueColor(const string param_name) const;
|
| bool ReadParamValueBool(const string param_name) const;
|
|
|
| //--- Funciones para trabajar con no parametyros
|
| //- Añade al final
|
| void AddNoParamsLine(const string& line);
|
|
|
| // Mencionar que idx es el indice en el FILE
|
| //- Inserta
|
| void InsertNoParamLine(const int idx, const string& line);
|
|
|
| //- Modifica
|
| void ModifyNoParamLine(const int idx, const string& new_line);
|
|
|
| //---
|
| bool IsValidIdxLine(const int idx) { return idx >= 0 && idx < m_lines_size; }
|
|
|
| //---
|
| CHashMap<string, int>* HashMapPointer() { return m_hashmap_params; }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| CSetFile::CSetFile(void)
|
| {
|
| m_hashmap_params = new CHashMap<string, int>();
|
| Clean(); // Inicilizacion
|
|
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| CSetFile::~CSetFile()
|
| {
|
| if(CheckPointer(m_hashmap_params) == POINTER_DYNAMIC)
|
| delete m_hashmap_params;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CSetFile::Clean(void)
|
| {
|
| m_hashmap_params.Clear();
|
| m_lines_size = ArrayResize(m_lines, 0);
|
| m_params_size = ArrayResize(m_params, 0);
|
| m_no_params_size = ArrayResize(m_no_params, 0);
|
| m_expert_name = NULL;
|
| m_saved_time = 0;
|
| m_init = false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Funciones de carga Load |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::Init(const string &expert_name)
|
| {
|
| //---
|
| if(m_init)
|
| {
|
| LogWarning("Limpiando dado que se inicia denuevo", FUNCION_ACTUAL);
|
| Clean();
|
| }
|
|
|
| //---
|
| m_expert_name = expert_name;
|
| m_saved_time = TimeLocal();
|
| m_init = true;
|
|
|
| //---
|
| m_no_params_size = ArrayResize(m_no_params, 4);
|
| m_no_params[0] = StringFormat("; saved on %s", TimeToString(m_saved_time, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
|
| m_no_params[1] = StringFormat("; this file contains input parameters for testing/optimizing %s expert advisor", m_expert_name);
|
| m_no_params[2] = "; to use it in the strategy tester, click Load in the context menu of the Inputs tab";
|
| m_no_params[3] = ";";
|
|
|
| //---
|
| m_lines_size = ArrayResize(m_lines, 4);
|
| m_lines[0].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[0].id = 0;
|
| m_lines[1].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[1].id = 1;
|
| m_lines[2].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[2].id = 2;
|
| m_lines[3].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[3].id = 3;
|
|
|
| //---
|
| return true;
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::InitBySrc(const string &src, ushort separator, uint reserve)
|
| {
|
| //---
|
| if(m_init)
|
| {
|
| LogWarning("Limpiando dado que se inicia denuevo", FUNCION_ACTUAL);
|
| Clean();
|
| }
|
|
|
| //---
|
| string arr[];
|
| const int size = StringSplit(src, separator, arr);
|
| if(size == -1)
|
| {
|
| LogError("Fallo al hacer split", FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| int ilec = 0;
|
|
|
| //--- Reservamos para no params
|
| reserve = fmax(3, reserve); // Como minimo un valor de 2
|
| int cn = ArrayResize(m_no_params, reserve);
|
|
|
| //---
|
| int rl = ArrayResize(m_lines, reserve);
|
|
|
|
|
| //--- Extramoes el tiempo de guardado
|
| string line = arr[ilec++];
|
| int len = StringLen(line);
|
| int pos = 0;
|
| while(line[pos] < '0' || line[pos] > '9') // Solo iterar mientras el caracter pos no sea un nuemro
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la primera linea debe de ubicarse un nuermo (fecha de creacion)", FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| m_saved_time = StringToTime(StringSubstr(line, pos)); // Desde el inicio del numero hasta el fin del string
|
|
|
| // Add
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[m_lines_size++].id = m_no_params_size;
|
| m_no_params[m_no_params_size++] = line;
|
|
|
| //--- Extraemos el nombre del bot
|
| line = arr[ilec++];
|
| len = StringLen(line);
|
| pos = 0;
|
|
|
| // Primero buscaremos /
|
| while(line[pos] != '/')
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la segunda linea del archivo se debe de ubicar el caracter / ", FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| // Avanzamos hasta el siguiente espacio
|
| while(line[pos] != ' ')
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la segunda linea del archivo se debe de ubicar el caracter / ", FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| pos++; // Luego del espacio (inicio del nombre del bot)
|
|
|
| // Comenzamos desde el fin hasta el 2do espacio
|
| int c = 2;
|
| int end = len - 1;
|
| while(c > 0)
|
| {
|
| end--;
|
| if(end < 0)
|
| {
|
| LogError("En la segunda linea del archivo deben de al menos haber dos espacios empezados desde atras ", FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| if(line[end] == ' ')
|
| c--;
|
| }
|
|
|
| m_expert_name = StringSubstrRange(line, pos, end);
|
|
|
| // Add
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[m_lines_size++].id = m_no_params_size;
|
| m_no_params[m_no_params_size++] = line;
|
|
|
|
|
| //---
|
| c = ArrayResize(m_params, reserve);
|
|
|
| //--- Cargamos todos los parametros
|
| while(ilec < size)
|
| {
|
| line = arr[ilec++];
|
| if(line == NULL)
|
| continue;
|
|
|
| //---
|
| if(line[0] == ';') // Comentarios | Sinput
|
| {
|
| //---
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[m_lines_size++].id = m_no_params_size;
|
|
|
| //---
|
| m_no_params[m_no_params_size++] = line;
|
| if(m_no_params_size >= cn)
|
| {
|
| cn <<= 1;
|
| ArrayResize(m_no_params, cn);
|
| }
|
| }
|
| else
|
| {
|
| //---
|
| int vs = line.Find("=");
|
| if(vs == -1)
|
| {
|
| LogWarning(StringFormat("Omitiendo linea corrupta:\n'%s'", line), FUNCION_ACTUAL);
|
| continue;
|
| }
|
|
|
| //---
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines[m_lines_size++].id = m_params_size;
|
|
|
| //---
|
| m_params[m_params_size].name = StringSubstr(line, 0, vs);
|
| if(!m_hashmap_params.Add(m_params[m_params_size].name, m_params_size))
|
| {
|
| LogError(StringFormat("Fallo al agregar el parametro =%s al hashmap", m_params[m_params_size].name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| vs++;
|
|
|
| //---
|
| const int t = StringSplitStr(StringSubstr(line, vs), "||", g_setfile_dyn_arr, 5);
|
| if(t < 1)
|
| {
|
| LogCriticalError("El split debe dar como minimo 1 cadena de resultado", FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| m_params[m_params_size].value = g_setfile_dyn_arr[0];
|
|
|
| //---
|
| if(t == 5 && g_setfile_dyn_arr[4].Find("N") >= 0) // Optimizable
|
| {
|
| m_params[m_params_size].start = g_setfile_dyn_arr[1];
|
| m_params[m_params_size].step = g_setfile_dyn_arr[2];
|
| m_params[m_params_size].stop = g_setfile_dyn_arr[3];
|
| }
|
|
|
| //---
|
| m_params_size++;
|
|
|
| //---
|
| if(m_params_size >= c)
|
| {
|
| c <<= 1;
|
| ArrayResize(m_params, c);
|
| }
|
| }
|
|
|
| //---
|
| if(m_lines_size >= rl)
|
| {
|
| rl <<= 1;
|
| ArrayResize(m_lines, rl);
|
| }
|
| }
|
|
|
| //--- Truncamos
|
| ArrayResize(m_params, m_params_size);
|
| ArrayResize(m_no_params, m_no_params_size);
|
| ArrayResize(m_lines, m_lines_size);
|
|
|
| //---
|
| m_init = true;
|
|
|
| //--- Exito
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::InitByFile(const string &file_name, int extra_file_flags, uint reserve)
|
| {
|
| //---
|
| if(m_init)
|
| {
|
| LogWarning("Limpiando dado que se inicia denuevo", FUNCION_ACTUAL);
|
| Clean();
|
| }
|
|
|
| //---
|
| ResetLastError();
|
| const int fh = FileOpen(file_name, FILE_READ | FILE_TXT | extra_file_flags);
|
| if(fh == INVALID_HANDLE)
|
| {
|
| LogError(StringFormat("Fallo al abrir el archivo '%s', ultimo error = %d", file_name, GetLastError()), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
|
|
| //--- Reservamos para no params
|
| reserve = fmax(3, reserve); // Como minimo un valor de 2
|
| int cn = ArrayResize(m_no_params, reserve);
|
|
|
| //---
|
| int rl = ArrayResize(m_lines, reserve);
|
|
|
|
|
| //--- Extramoes el tiempo de guardado
|
| string line = FileReadString(fh);
|
| int len = StringLen(line);
|
| int pos = 0;
|
| while(line[pos] < '0' || line[pos] > '9') // Solo iterar mientras el caracter pos no sea un nuemro
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la primera linea debe de ubicarse un nuermo (fecha de creacion)", FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| m_saved_time = StringToTime(StringSubstr(line, pos)); // Desde el inicio del numero hasta el fin del string
|
|
|
| // Add
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[m_lines_size++].id = m_no_params_size;
|
| m_no_params[m_no_params_size++] = line;
|
|
|
| //--- Extraemos el nombre del bot
|
| line = FileReadString(fh);
|
| len = StringLen(line);
|
| pos = 0;
|
|
|
| // Primero buscaremos /
|
| while(line[pos] != '/')
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la segunda linea del archivo se debe de ubicar el caracter / ", FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| // Avanzamos hasta el siguiente espacio
|
| while(line[pos] != ' ')
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la segunda linea del archivo se debe de ubicar el caracter / ", FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| pos++; // Luego del espacio (inicio del nombre del bot)
|
|
|
| // Comenzamos desde el fin hasta el 2do espacio
|
| int c = 2;
|
| int end = len - 1;
|
| while(c > 0)
|
| {
|
| end--;
|
| if(end < 0)
|
| {
|
| LogError("En la segunda linea del archivo deben de al menos haber dos espacios empezados desde atras ", FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| if(line[end] == ' ')
|
| c--;
|
| }
|
|
|
| m_expert_name = StringSubstrRange(line, pos, end);
|
|
|
| // Add
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[m_lines_size++].id = m_no_params_size;
|
| m_no_params[m_no_params_size++] = line;
|
|
|
|
|
| //---
|
| c = ArrayResize(m_params, reserve);
|
|
|
| //--- Cargamos todos los parametros
|
| while(!FileIsEnding(fh))
|
| {
|
| line = FileReadString(fh);
|
| if(line == NULL)
|
| continue;
|
|
|
| //---
|
| if(line[0] == ';') // Comentarios | Sinput
|
| {
|
| //---
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[m_lines_size++].id = m_no_params_size;
|
|
|
| //---
|
| m_no_params[m_no_params_size++] = line;
|
| if(m_no_params_size >= cn)
|
| {
|
| cn <<= 1;
|
| ArrayResize(m_no_params, cn);
|
| }
|
| }
|
| else
|
| {
|
| //---
|
| int vs = line.Find("=");
|
| if(vs == -1)
|
| {
|
| LogWarning(StringFormat("Omitiendo linea corrupta:\n'%s'", line), FUNCION_ACTUAL);
|
| continue;
|
| }
|
|
|
|
|
| //---
|
| m_lines[m_lines_size].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines[m_lines_size++].id = m_params_size;
|
|
|
| //---
|
| m_params[m_params_size].name = StringSubstr(line, 0, vs);
|
| if(!m_hashmap_params.Add(m_params[m_params_size].name, m_params_size))
|
| {
|
| LogError(StringFormat("Fallo al agregar el parametro =%s al hashmap", m_params[m_params_size].name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| vs++;
|
|
|
| //---
|
| const int t = StringSplitStr(StringSubstr(line, vs), "||", g_setfile_dyn_arr, 5);
|
| if(t < 1)
|
| {
|
| LogCriticalError("El split debe dar como minimo 1 cadena de resultado", FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| m_params[m_params_size].value = g_setfile_dyn_arr[0];
|
|
|
| //---
|
| if(t == 5 && g_setfile_dyn_arr[4].Find("N") >= 0) // Optimizable
|
| {
|
| m_params[m_params_size].start = g_setfile_dyn_arr[1];
|
| m_params[m_params_size].step = g_setfile_dyn_arr[2];
|
| m_params[m_params_size].stop = g_setfile_dyn_arr[3];
|
| }
|
|
|
| //---
|
| m_params_size++;
|
|
|
| //---
|
| if(m_params_size >= c)
|
| {
|
| c <<= 1;
|
| ArrayResize(m_params, c);
|
| }
|
| }
|
|
|
| //---
|
| if(m_lines_size >= rl)
|
| {
|
| rl <<= 1;
|
| ArrayResize(m_lines, rl);
|
| }
|
| }
|
|
|
| //--- Truncamos
|
| ArrayResize(m_params, m_params_size);
|
| ArrayResize(m_no_params, m_no_params_size);
|
| ArrayResize(m_lines, m_lines_size);
|
|
|
| //--- Cerramos
|
| FileClose(fh);
|
|
|
| //---
|
| m_init = true;
|
|
|
| //--- Exito
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::Save(const string &file_name, int extra_file_flags)
|
| {
|
| //---
|
| ResetLastError();
|
| const int fh = FileOpen(file_name, FILE_WRITE | FILE_TXT | extra_file_flags);
|
| if(fh == INVALID_HANDLE)
|
| {
|
| LogError(StringFormat("Fallo al abrir el archivo = %s, ultimo error = %d", file_name, GetLastError()), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| ChangeSavedTime(TimeLocal());
|
|
|
| //---
|
| for(int i = 0; i < m_lines_size; i++)
|
| {
|
| if(m_lines[i].type == SETFILE_LINE_TYPE_INPUT)
|
| {
|
| FileWrite(fh, m_params[m_lines[i].id].Format());
|
| }
|
| else
|
| {
|
| FileWrite(fh, m_no_params[m_lines[i].id]);
|
| }
|
| }
|
|
|
| //---
|
| FileClose(fh);
|
|
|
| //---
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CSetFile::GetAsString(string &out) const
|
| {
|
| //ArrayPrint(m_lines);
|
| for(int i = 0; i < m_lines_size; i++)
|
| {
|
| if(m_lines[i].type == SETFILE_LINE_TYPE_INPUT)
|
| {
|
| //Print(m_lines[i].id);
|
| out += m_params[m_lines[i].id].Format() + "\n";
|
| }
|
| else
|
| {
|
| out += m_no_params[m_lines[i].id] + "\n";
|
| }
|
| }
|
| if(m_lines_size > 0)
|
| out.Truncate(out.Length() - 1);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| int CSetFile::GetAsStringArray(string &out[]) const
|
| {
|
| int s = ArrayResize(out, m_lines_size);
|
| for(int i = 0; i < m_lines_size; i++)
|
| {
|
| if(m_lines[i].type == SETFILE_LINE_TYPE_INPUT)
|
| {
|
| out[i] = m_params[m_lines[i].id].Format();
|
| }
|
| else
|
| {
|
| out[i] = m_no_params[m_lines[i].id];
|
| }
|
| }
|
| return s;
|
| }
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CSetFile::Summary(void) const
|
| {
|
| Print("---- Expert name: ", m_expert_name);
|
| Print(" Saved time: ", m_saved_time);
|
| Print(" Total lines: ", m_lines_size);
|
| Print(" Total params: ", m_params_size);
|
| Print(" Total no params: ", m_no_params_size);
|
| }
|
| //+------------------------------------------------------------------+
|
| void CSetFile::Imprimir(void) const
|
| {
|
| string str = "";
|
| GetAsString(str);
|
| Print(str);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| __forceinline SetFileParam CSetFile::GetParam(const string str) const
|
| {
|
| //---
|
| static int real_idx;
|
| ((CSetFile*)&this).m_hashmap_params.TryGetValue(str, real_idx);
|
| return m_params[real_idx]; // Sin comprobacion en caso de error INVALID
|
| // La idea es que si el parametro es invalido (no existe) y se llame a esta funcion entonces de error
|
| // En caso de las demas funcoines se retonan un bool (por algo) para saber si se modifico o no
|
| // En cambio aqui retonamos directamente un valor
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| __forceinline int CSetFile::GetParamIdx(const string str) const
|
| {
|
| //---
|
| int real_idx = INVALID_INDEX;
|
| ((CSetFile*)&this).m_hashmap_params.TryGetValue(str, real_idx);
|
| return real_idx;
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modificar el nombre del parametro |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamName(const int idx, const string &new_name)
|
| {
|
| //---
|
| const int real_idx = m_lines[idx].id;
|
|
|
| //---
|
| if(!m_hashmap_params.Remove(m_params[real_idx].name))
|
| {
|
| LogError(StringFormat("No se pudo remover del hashmap, param name = %s", m_params[real_idx].name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| m_params[real_idx].name = new_name;
|
|
|
| //---
|
| if(m_hashmap_params.Add(new_name, real_idx))
|
| {
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("No se pudo agregatr el parametro con nombre = %s, al hashamp", new_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamName(const string param_name, const string &new_name)
|
| {
|
| //---
|
| static int real_idx;
|
|
|
| //---
|
| if(!m_hashmap_params.TryGetValue(param_name, real_idx))
|
| {
|
| LogError(StringFormat("El parametro = %s, no existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| if(!m_hashmap_params.Remove(m_params[real_idx].name))
|
| {
|
| LogError(StringFormat("No se pudo remover del hashmap, param name = %s", m_params[real_idx].name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| m_params[real_idx].name = new_name;
|
|
|
| //---
|
| if(m_hashmap_params.Add(new_name, real_idx))
|
| {
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("No se pudo agregatr el parametro con nombre = %s, al hashamp", new_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modify value |
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| bool CSetFile::ModifyParamValueNumber(const string param_name, const TInteger v)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = string(v);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| bool CSetFile::ModifyParamValueRealNumber(const string param_name, const TNumber v, int8_t presicion)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = DoubleToString(v, presicion);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamValueBoolean(const string param_name, const bool v)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = v ? "true" : "false";
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamValueString(const string param_name, const string v)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = v;
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TEnum>
|
| bool CSetFile::ModifyParamValueEnum(const string param_name, const TEnum v)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = string((int)v);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamValueDatetime(const string param_name, const datetime v)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = string(long(v));
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamValueColor(const string param_name, const color v)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].value = string((int)v);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modify datetime |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamOptDatetimeStart(const string param_name, const datetime start)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].start = string(long(start));
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamOptDatetimeStep(const string param_name, const long step_sec)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].step = string(step_sec);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ModifyParamOptDatetimeStop(const string param_name, const datetime stop)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].stop = string(long(stop));
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modificar Number Opt |
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| bool CSetFile::ModifyParamOptNumberStart(const string param_name, const TInteger start)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].start = string(start);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| bool CSetFile::ModifyParamOptNumberStep(const string param_name, const TInteger step)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].step = string(step);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| bool CSetFile::ModifyParamOptNumberStop(const string param_name, const TInteger stop)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].stop = string(stop);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modificar Real Number Opt |
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| bool CSetFile::ModifyParamOptRealNumberStart(const string param_name, const TNumber start, int8_t presicion)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].start = DoubleToString(start, presicion);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| bool CSetFile::ModifyParamOptRealNumberStep(const string param_name, const TNumber step, int8_t presicion)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].step = DoubleToString(step, presicion);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| bool CSetFile::ModifyParamOptRealNumberStop(const string param_name, const TNumber stop, int8_t presicion)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].stop = DoubleToString(stop, presicion);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Enum |
|
| //+------------------------------------------------------------------+
|
| template <typename TEnum>
|
| bool CSetFile::ModifyParamOptEnumStart(const string param_name, const TEnum start)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].start = string((int)start);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TEnum>
|
| bool CSetFile::ModifyParamOptEnumStop(const string param_name, const TEnum stop)
|
| {
|
| static int idx;
|
| if(m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| m_params[idx].stop = string((int)stop);
|
| return true;
|
| }
|
| else
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Funcion general para remover una linea |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::RemoveLine(const int idx)
|
| {
|
| //---
|
| const int ri = m_lines[idx].id;
|
| const ENUM_SETFILE_LINE_TYPE type = m_lines[idx].type;
|
| for(int i = idx; i < m_lines_size - 1; i++)
|
| {
|
| m_lines[i] = m_lines[i + 1];
|
| }
|
| ArrayResize(m_lines, (--m_lines_size));
|
| //---
|
| /*
|
| S = Parametro REAl Pararm (params)
|
| N = No paramero (no_params)
|
| LTYPE= Tipo de linea, como valores toma 2 = [S, N]
|
|
|
| # Ejemplo de array
|
| m_lines m_params m_no_params
|
| LTYPE PARAMIDX NOPARAMIDX
|
| S 0 -
|
| S 1 -
|
| S 2 -
|
| S 3 -
|
| S 4 -
|
|
|
| # Eliminamos linea 0
|
| m_lines m_params m_no_params
|
| LTYPE PARAMIDX NOPARAMIDX
|
| S 1 -
|
| S 2 -
|
| S 3 -
|
| S 4 -
|
|
|
| # Aqui habria que reducir paramidx en los restantes?¿
|
| Ahora mismo pasaria esto:
|
| Hariamos un swap entre elemtno eliminamo y utlimo
|
| asi que se camiba de posicon 4->0
|
| asi que el indice sero apunta al 4
|
|
|
| m_lines m_params m_no_params
|
| LTYPE PARAMIDX NOPARAMIDX
|
| S 1 -
|
| S 2 -
|
| S 3 -
|
| S 0 -
|
|
|
| # Vale enotnces deberimaos de ubicar y reponde "Donde se ubica el linea con real index = last" ?
|
| # Una vez tengamos su indice poor ejemplo en nuestro ejemplo seria el indice 4 entonces modificamos m_lines[4].id = ri
|
| */
|
|
|
| //---
|
| if(type == SETFILE_LINE_TYPE_INPUT)
|
| {
|
| //---
|
| if(!m_hashmap_params.Remove(m_params[ri].name))
|
| {
|
| LogError(StringFormat("Fallo al eliminar el parametro '%s' del hashmap", m_params[ri].name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
|
|
| //---
|
| const int last = (--m_params_size);
|
| if(ri != last) // Solo si no es igual no es 0 como minimo hayt 1 elemneo
|
| {
|
| m_params[ri] = m_params[last];
|
|
|
| if(!m_hashmap_params.TrySetValue(m_params[ri].name, ri))
|
| {
|
| LogError(StringFormat("Error al modificar el valor de %s a idx = %d", m_params[ri].name, ri), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| }
|
|
|
| //---
|
| // Ahora su RI de ester parametro cambia ya no apunta a
|
| for(int i = 0; i < m_lines_size; i++)
|
| {
|
| if(m_lines[i].type == SETFILE_LINE_TYPE_INPUT && m_lines[i].id == last) //
|
| {
|
| m_lines[i].id = ri;
|
| break;
|
| }
|
| }
|
|
|
| //---
|
| ArrayResize(m_params, m_params_size);
|
| }
|
| else
|
| {
|
| int last = --m_no_params_size;
|
| if(ri != last)
|
| {
|
| m_no_params[ri] = m_no_params[last];
|
| for(int i = 0; i < m_lines_size; i++) // Redirigir la linea que apuntaba a last
|
| {
|
| if(m_lines[i].type == SETFILE_LINE_TYPE_NOINPUT && m_lines[i].id == last)
|
| {
|
| m_lines[i].id = ri;
|
| break;
|
| }
|
| }
|
| }
|
| ArrayResize(m_no_params, m_no_params_size);
|
| }
|
|
|
| //---
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Funciones para trabnajar con lineas no param |
|
| //+------------------------------------------------------------------+
|
| void CSetFile::AddNoParamsLine(const string &line)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_no_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_NOINPUT;
|
| ArrayResize(m_no_params, m_no_params_size + 1);
|
| m_no_params[m_no_params_size++] = line;
|
| }
|
| //+------------------------------------------------------------------+
|
| void CSetFile::InsertNoParamLine(const int idx, const string &line)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].type = SETFILE_LINE_TYPE_NOINPUT;
|
| m_lines[idx].id = m_no_params_size;
|
| m_lines_size++;
|
|
|
| ArrayResize(m_no_params, m_no_params_size + 1);
|
| m_no_params[m_no_params_size++] = line;
|
| }
|
| //+------------------------------------------------------------------+
|
| void CSetFile::ModifyNoParamLine(const int idx, const string &new_line)
|
| {
|
| // NO hay check de idx
|
| m_no_params[m_lines[idx].id] = new_line;
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Añadir parametros al final |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::AddParamLineString(const string &name, const string &value)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size++].value = value;
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| bool CSetFile::AddParamLineNumber(const string &name, const TInteger value, const TInteger start, const TInteger step, const TInteger stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = string(value);
|
| m_params[m_params_size].start = string(start);
|
| m_params[m_params_size].step = string(step);
|
| m_params[m_params_size++].stop = string(stop);
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| bool CSetFile::AddParamLineReal(const string &name, const TNumber value, int8_t presicion, const TNumber start, const TNumber step, const TNumber stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = DoubleToString(value, presicion);
|
| m_params[m_params_size].start = DoubleToString(start, presicion);
|
| m_params[m_params_size].step = DoubleToString(step, presicion);
|
| m_params[m_params_size++].stop = DoubleToString(stop, presicion);
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::AddParamLineBool(const string &name, const bool value)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = value ? "true" : "false";
|
| m_params[m_params_size].start = "false";
|
| m_params[m_params_size].step = "0";
|
| m_params[m_params_size++].stop = "true";
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TEnum>
|
| bool CSetFile::AddParamLineEnum(const string &name, const TEnum value, const TEnum start, const TEnum stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = string((int)value);
|
| m_params[m_params_size].start = string((int)start);
|
| m_params[m_params_size].step = "0";
|
| m_params[m_params_size++].stop = string((int)stop);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::AddParamLineDatetime(const string &name, const datetime value, const datetime start, const long step_sec, const datetime stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = string(long(value));
|
| m_params[m_params_size].start = string(long(start));
|
| m_params[m_params_size].step = string(step_sec);
|
| m_params[m_params_size++].stop = string(long(stop));
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::AddParamLineColor(const string &name, const color value)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| m_lines[m_lines_size].id = m_params_size;
|
| m_lines[m_lines_size++].type = SETFILE_LINE_TYPE_INPUT;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size++].value = string((int)value);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::InsertParamLineString(const int idx, const string &name, const string &value)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size++].value = value;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| bool CSetFile::InsertParamLineNumber(const int idx, const string &name, const TInteger value, const TInteger start, const TInteger step, const TInteger stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = string(value);
|
| m_params[m_params_size].start = string(start);
|
| m_params[m_params_size].step = string(step);
|
| m_params[m_params_size++].stop = string(stop);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| bool CSetFile::InsertParamLineReal(const int idx, const string &name, const TNumber value, int8_t presicion, const TNumber start, const TNumber step, const TNumber stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = DoubleToString(value, presicion);
|
| m_params[m_params_size].start = DoubleToString(start, presicion);
|
| m_params[m_params_size].step = DoubleToString(step, presicion);
|
| m_params[m_params_size++].stop = DoubleToString(stop, presicion);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::InsertParamLineBool(const int idx, const string &name, const bool value)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = value ? "true" : "false";
|
| m_params[m_params_size].start = "false";
|
| m_params[m_params_size].step = "0";
|
| m_params[m_params_size++].stop = "true";
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| template <typename TEnum>
|
| bool CSetFile::InsertParamLineEnum(const int idx, const string &name, const TEnum value, const TEnum start, const TEnum stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = string((int)value);
|
| m_params[m_params_size].start = string((int)start);
|
| m_params[m_params_size].step = "0";
|
| m_params[m_params_size++].stop = string((int)stop);
|
| return true;
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::InsertParamLineDatetime(const int idx, const string &name, const datetime value, const datetime start, const long step_sec, const datetime stop)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size].value = string(long(value));
|
| m_params[m_params_size].start = string(long(start));
|
| m_params[m_params_size].step = string(step_sec);
|
| m_params[m_params_size++].stop = string(long(stop));
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::InsertParamLineColor(const int idx, const string &name, const color value)
|
| {
|
| ArrayResize(m_lines, m_lines_size + 1);
|
| for(int i = m_lines_size; i > idx; i--)
|
| m_lines[i] = m_lines[i - 1];
|
| m_lines[idx].id = m_params_size;
|
| m_lines[idx].type = SETFILE_LINE_TYPE_INPUT;
|
| m_lines_size++;
|
| if(!m_hashmap_params.Add(name, m_params_size))
|
| {
|
| LogError(StringFormat("No se puede agregar el parametro con el nombre = %s", name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| ArrayResize(m_params, m_params_size + 1);
|
| m_params[m_params_size].name = name;
|
| m_params[m_params_size++].value = string((int)value);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Read value |
|
| //+------------------------------------------------------------------+
|
| string CSetFile::ReadParamValueString(const string param_name) const
|
| {
|
| static int idx;
|
| if(!((CSetFile*)&this).m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return NULL;
|
| }
|
| return m_params[idx].value;
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TInteger>
|
| TInteger CSetFile::ReadParamValueInteger(const string param_name) const
|
| {
|
| static int idx;
|
| if(!((CSetFile*)&this).m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return (TInteger)0;
|
| }
|
| return TInteger(m_params[idx].value);
|
| }
|
| //+------------------------------------------------------------------+
|
| template <typename TNumber>
|
| TNumber CSetFile::ReadParamValueReal(const string param_name) const
|
| {
|
| static int idx;
|
| if(!((CSetFile*)&this).m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return (TNumber)0.0;
|
| }
|
| return TNumber(m_params[idx].value);
|
| }
|
| //+------------------------------------------------------------------+
|
| datetime CSetFile::ReadParamValueDatetime(const string param_name) const
|
| {
|
| static int idx;
|
| if(!((CSetFile*)&this).m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return 0;
|
| }
|
| return datetime(long(m_params[idx].value));
|
| }
|
| //+------------------------------------------------------------------+
|
| color CSetFile::ReadParamValueColor(const string param_name) const
|
| {
|
| static int idx;
|
| if(!((CSetFile*)&this).m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return clrNONE;
|
| }
|
| return color(int(m_params[idx].value));
|
| }
|
| //+------------------------------------------------------------------+
|
| bool CSetFile::ReadParamValueBool(const string param_name) const
|
| {
|
| static int idx;
|
| if(!((CSetFile*)&this).m_hashmap_params.TryGetValue(param_name, idx))
|
| {
|
| LogError(StringFormat("El parametro '%s' No existe", param_name), FUNCION_ACTUAL);
|
| return false;
|
| }
|
| return m_params[idx].value == "true";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| void CSetFile::ChangeSavedTime(const datetime new_time)
|
| {
|
| if(m_lines_size < 1)
|
| {
|
| LogCriticalError("SetFile vacio", FUNCION_ACTUAL);
|
| return;
|
| }
|
|
|
| //---
|
| const int ri = m_lines[0].id;
|
|
|
| //---
|
| int len = StringLen(m_no_params[ri]);
|
| int pos = 0;
|
| while(m_no_params[ri][pos] < '0' || m_no_params[ri][pos] > '9') // Solo iterar mientras el caracter pos no sea un nuemro
|
| {
|
| pos++;
|
| if(pos >= len)
|
| {
|
| LogError("En la primera linea debe de ubicarse un nuermo (fecha de creacion)", FUNCION_ACTUAL);
|
| return;
|
| }
|
| }
|
| // Truincamos el nombre del string hasta el pos (la idea es eliminar el time)
|
| m_no_params[ri].Truncate(pos);
|
| m_no_params[ri] += TimeToString(new_time, TIME_MINUTES | TIME_DATE | TIME_SECONDS);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| #endif // MQLARTICLES_UTILS_SETFILES_MAIN_MQH
|