MQLArticles/IndicatorsCts/Imp/Internal/old/App.mqh
2026-11-01 10:04:13 -05:00
753 lines
23 KiB
MQL5
//+------------------------------------------------------------------+
//| App.mqh |
//| Copyright 2026, Niquel Mendoza. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza."
#property link "https://www.mql5.com"
#property strict
#ifndef MQLARTICLES_INDICATORSCTS_IMP_INTERNLA_APP_MQH
#define MQLARTICLES_INDICATORSCTS_IMP_INTERNLA_APP_MQH
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#include "Def.mqh"
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
class CApp : public CLoggerBase
{
private:
TSN::CJsonParser m_json;
//---
//string m_fn_out_pool;
string m_fn_src_file_ind; // arhcivo de config de indicaodres (json)
//---
/*uchar m_file_pool[];
int m_file_pool_s;
int m_file_pool_r;*/
//--- Archivo de indicadores
uchar m_file_ind_guard[256]; // Buffer del guard
int m_file_ind_guard_s; // Numero de bytes ocupados guard
uchar m_file_ind[]; // Buffer del archivo ind
int m_file_ind_s; // Tamaño del archivo ind
int m_file_ind_r; // Tamaño real (reserva) del archivo ind
string m_fn_out_ind; // Name del archivo final de esctritura
//---
const ulong m_hash_relative;
//--- Procesar json
bool ProccesConfig();
bool ProccesIndicators();
//--- Utilidades de archivos
bool AssingFileWJson(const string& file);
bool SaveFile(const uchar& raw[], int size, const string& file);
//---
bool FileProrrogo(TSN::CJsonNode& file,
uchar& raw[], int& raw_s, int& raw_r, string& out_path);
//--- Utilidades de escritura
void FileAddLineWC(const string& line, uchar& raw[], int& raw_s);
void FileAddLineWC(const uchar& line[], int line_s, int line_len, uchar& raw[], int& raw_s);
void FileAddInclude(const bool relative, uchar& raw[], int& raw_s,
const uchar& include[], int inc_start, int inc_len);
void AddGuardEnd(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len);
void FileAddGuardInit(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len);
//--- Utilidad para json
int JsonObjStrLen(TSN::CJsonNode& node, const uchar& in[]);
public:
CApp(void);
~CApp(void) {}
//---
bool Run(const string& fn_config);
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CApp::CApp(void)
: m_hash_relative(TSN::FNV1a_64("relative", StringLen("relative"))), m_fn_src_file_ind(NULL),
//---
m_file_ind_s(0), m_file_ind_r(0), m_fn_out_ind(NULL), m_file_ind_guard_s(0)
{
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CApp::AssingFileWJson(const string &file)
{
//---
HANDLE handle = kernel32::CreateFileW(file, GENERIC_READ, SHARE_READ, 0, OPEN_EXISTING, 0, 0);
if(handle == INVALID_HANDLE)
{
LogError(::StringFormat("Failed to open file = %s, last err = %d",
file, kernel32::GetLastError()), FUNCION_ACTUAL);
return false;
}
//---
long size;
kernel32::GetFileSizeEx(handle, size);
uint read;
//---
const int isize = (int)size;
m_json.m_len = isize;
::ArrayResize(m_json.m_raw, m_json.m_len);
kernel32::ReadFile(handle, m_json.m_raw, (uint)isize, read, 0);
kernel32::CloseHandle(handle);
//---
m_json.NormalizeUft();
//---
if(!m_json.Parse())
{
LogError(::StringFormat("Fallo al parsear json:\nFile: '%s'\n", file), FUNCION_ACTUAL);
m_json.ErrorInfo();
return false;
}
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CApp::SaveFile(const uchar &raw[], int size, const string &file)
{
//---
HANDLE handle = kernel32::CreateFileW(file, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
if(handle == INVALID_HANDLE)
{
LogCriticalError(::StringFormat("Failed to create file:\n'%s'\nLast err in kernel32 = %d",
file, kernel32::GetLastError()), FUNCION_ACTUAL);
return false;
}
//---
uint writen = 0;
kernel32::WriteFile(handle, raw, sizeof(uchar) * size, writen, NULL);
kernel32::CloseHandle(handle);
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CApp::Run(const string& fn_config)
{
//--- Parseamos la configuracion
if(!AssingFileWJson(fn_config))
return false;
if(!ProccesConfig())
return false;
//--- Parseamos ahora si el archivo de indicadores
if(!AssingFileWJson(m_fn_src_file_ind))
return false;
//---
if(!ProccesIndicators())
return false;
//--- Guardamos el archivo final
if(!SaveFile(m_file_ind, m_file_ind_s, m_fn_out_ind))
return false;
//---
LogInfo("Se termino", FUNCION_ACTUAL);
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CApp::ProccesConfig(void)
{
//---
TSN::CJsonNode root = m_json.GetRoot();
//---
if(!root["src_inds_file"].ToStringSafe(m_fn_src_file_ind))
{
LogError("Falta el campo 'src_inds_file' que idnica el archivo donde estan los indicadores, o esta malformado", FUNCION_ACTUAL);
return false;
}
//---
if(!FileProrrogo(root["main_file"], m_file_ind,
m_file_ind_s, m_file_ind_r, m_fn_out_ind))
return false;
/* if(!FileProrrogo(root["pool_file"], m_file_pool,
m_file_pool_s, m_file_pool_r, m_fn_out_pool))
return false;*/
//---
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CApp::FileProrrogo(TSN::CJsonNode& file,
uchar& raw[], int& raw_s, int& raw_r, string& out_path)
{
//--- Reserva inicial
SCRIPT_RESERVE_ARR(raw, raw_s, raw_r, 2048)
//---
if(!file["path"].ToStringSafe(out_path))
{
LogError("No se pudo obtener el campo path", FUNCION_ACTUAL);
return false;
}
//---
const string pure = TSN::CPathUtils::GetPureFileName(out_path); // nombre puro del archivo (sin barras y eso)
//--- parte inciial header de comentarios
//- primera linea
SCRIPT_ADD_ONE_LINE(raw, raw_s)
//- File
FileAddLineWC(pure, raw, raw_s);
//- (autor solo ascci puro)
const int autor_start = file["autor"].StrStart();
const int autor_len = file["autor"].StrLenRaw();
if(autor_len == 0 || autor_start == 0)
{
LogError(::StringFormat("Falta el campo autor en file = '%s'", pure), FUNCION_ACTUAL);
return false;
}
FileAddLineWC(m_json.m_raw, autor_start, autor_len, raw, raw_s);
//- (link solo ascci puro)
const int link_start = file["link"].StrStart();
const int link_len = file["link"].StrLenRaw();
if(link_len == 0 || link_start == 0)
{
LogError(::StringFormat("Falta el campo link en file = '%s'", pure), FUNCION_ACTUAL);
return false;
}
FileAddLineWC(m_json.m_raw, link_start, link_len, raw, raw_s);
//--- Linea de terminacion
SCRIPT_ADD_ONE_LINE(raw, raw_s)
//--- Ahora si parrte de props
//- copryrgith
SCRIPT_ADD_PROP(SCRIPT_PROP_COPYRIGHT, raw, raw_s)
raw[raw_s++] = '"';
raw_s += ArrayCopy(raw, m_json.m_raw, raw_s, autor_start, autor_len);
raw[raw_s++] = '"';
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
//- link
SCRIPT_ADD_PROP(SCRIPT_PROP_LINK, raw, raw_s)
raw[raw_s++] = '"';
raw_s += ArrayCopy(raw, m_json.m_raw, raw_s, link_start, link_len);
raw[raw_s++] = '"';
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
//- strict
SCRIPT_ADD_PROP(SCRIPT_PROP_STRICT, raw, raw_s)
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
//--- Espacio separador
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
//--- Guards (trunca a 256 el guard)
const int guard_start = file["guard"].StrStart();
m_file_ind_guard_s = MathMin(file["guard"].StrLenRaw(), 256);
if(guard_start != 0 && m_file_ind_guard_s > 0)
{
ArrayCopy(m_file_ind_guard, m_json.m_raw, 0, guard_start, m_file_ind_guard_s); // copiamos
FileAddGuardInit(raw, raw_s, m_file_ind_guard, 0, m_file_ind_guard_s); // Agregamos el guard
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
}
//---
SCRIPT_ADD_ONE_BLOCK(raw, raw_s)
//--- Includes
// volvemos a reservas por si acaso
const int t = file["includes"].Size() * 256;
SCRIPT_RESERVE_ARR(raw, raw_s, raw_r, t)
//---
CJsonIteratorArray it = file["includes"].BeginArr();
while(it.IsValid())
{
TSN::CJsonNode include = it.Val();
ulong key_h;
if(!include.AtObjKey(0).KeyHashFVN1A64(key_h))
{
LogError("Se esperaba una key en el objeto de includes, no se obutvo nada", FUNCION_ACTUAL);
return false;
}
const bool is_rel = key_h == m_hash_relative;
int start = 0, len = 0;
if(is_rel) // relatvie
{
TSN::CJsonNode r = include["relative"];
start = r.StrStart();
len = r.StrLenRaw();
}
else // <>
{
TSN::CJsonNode m = include["mql5"];
if(m.IsInvalid())
{
LogError("Solo se permite dos tipos para los includes [relative, mql5] nada mas", FUNCION_ACTUAL);
return false;
}
start = m.StrStart();
len = m.StrLenRaw();
}
//--- truncamos si hace falta
FileAddInclude(is_rel, raw, raw_s, m_json.m_raw, start, MathMin(len, 256));
//---
it.Next();
}
//---
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
//---
LogInfo(::StringFormat("Archivo = '%s' procesado correctamente", pure), FUNCION_ACTUAL);
//---
return true; // terminamos el prologo
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CApp::FileAddLineWC(const string& line, uchar& raw[], int& raw_s)
{
//---
const int line_pure_size = SCRIPT_LINEW_PURESIZE; // espacio util
const int norm_len = MathMin(line_pure_size, StringLen(line));
const int rest_len = line_pure_size - norm_len; // espacio que necesitare
int to_copy_linew = 4 + rest_len; // cuanto copiar de linew
//---
raw_s += ArrayCopy(raw, g_res_linew, raw_s, 0, to_copy_linew); // ws
raw_s += StringToCharArray(line, raw, raw_s, norm_len, CP_UTF8); // ahora si
//---
raw[raw_s++] = ' ';
raw[raw_s++] = '|';
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
}
//+------------------------------------------------------------------+
void CApp::FileAddLineWC(const uchar& line[], int line_s, int line_len, uchar& raw[], int& raw_s)
{
//---
const int line_pure_size = SCRIPT_LINEW_PURESIZE; // espacio util
const int norm_len = MathMin(line_pure_size, line_len);
const int rest_len = line_pure_size - norm_len; // espacio que necesitare
int to_copy_linew = 4 + rest_len; // cuanto copiar de linew
//---
raw_s += ArrayCopy(raw, g_res_linew, raw_s, 0, to_copy_linew); // ws
raw_s += ArrayCopy(raw, line, raw_s, line_s, norm_len); // ahora si
//---
raw[raw_s++] = ' ';
raw[raw_s++] = '|';
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
}
//+------------------------------------------------------------------+
void CApp::FileAddGuardInit(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len)
{
//---
raw[raw_s++] = '#';
raw[raw_s++] = 'i';
raw[raw_s++] = 'f';
raw[raw_s++] = 'n';
raw[raw_s++] = 'd';
raw[raw_s++] = 'e';
raw[raw_s++] = 'f';
raw[raw_s++] = ' ';
raw_s += ArrayCopy(raw, guard, raw_s, guard_start, guard_len);
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
//---
raw[raw_s++] = '#';
raw[raw_s++] = 'd';
raw[raw_s++] = 'e';
raw[raw_s++] = 'f';
raw[raw_s++] = 'i';
raw[raw_s++] = 'n';
raw[raw_s++] = 'e';
raw[raw_s++] = ' ';
raw_s += ArrayCopy(raw, guard, raw_s, guard_start, guard_len);
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
}
//+------------------------------------------------------------------+
void CApp::AddGuardEnd(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len)
{
//---
raw[raw_s++] = '#';
raw[raw_s++] = 'e';
raw[raw_s++] = 'n';
raw[raw_s++] = 'd';
raw[raw_s++] = 'i';
raw[raw_s++] = 'f';
raw[raw_s++] = ' ';
raw[raw_s++] = '/';
raw[raw_s++] = '/';
//---
raw_s += ArrayCopy(raw, guard, raw_s, guard_start, guard_len);
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
}
//+------------------------------------------------------------------+
void CApp::FileAddInclude(const bool relative, uchar& raw[], int& raw_s, const uchar& include[], int inc_start, int inc_len)
{
//---
raw[raw_s++] = '#';
raw[raw_s++] = 'i';
raw[raw_s++] = 'n';
raw[raw_s++] = 'c';
raw[raw_s++] = 'l';
raw[raw_s++] = 'u';
raw[raw_s++] = 'd';
raw[raw_s++] = 'e';
raw[raw_s++] = ' ';
//---
raw[raw_s++] = relative ? '"' : '<';
//---
raw_s += ArrayCopy(raw, include, raw_s, inc_start, inc_len);
//---
raw[raw_s++] = relative ? '"' : '>';
//---
SCRIPT_ADD_LINETERMINATOR(raw, raw_s)
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CApp::JsonObjStrLen(TSN::CJsonNode& node, const uchar& in[])
{
//---
if(node.Size() < 1)
return 16; // Default size
//---
const int li = node.AtObjKey(0).StrStart() - 2; // Start de string
int read_i = li;
uchar c;
//---
int stack = 1;
//---
while(true)
{
//--- Saltamos los ws
while((c = in[++read_i]) < 33) {}
//--- Salimos
if(c == '}')
break;
//--- Verificamos si es string
if(c != '"')
continue;
//---
while((c = in[++read_i]) != '"')
{
if(c == '\\') // backslsaw saltamos
read_i++;
}
}
//--- retornamos
return (read_i - li) + 32;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CApp::ProccesIndicators(void)
{
//---
TSN::CJsonNode indicators = m_json.GetRoot()["indicators"];
if(indicators.IsInvalid())
{
LogError("No se encontro indicators en el root", FUNCION_ACTUAL);
return false;
}
//---
int expected_len = 0;
//--- Caluclo del len
CJsonIteratorArray it = indicators.BeginArr();
while(it.IsValid())
{
// 32 lineas de 256 carcteras mas el len del subnodo.. (contnado todos los chars) * 3 + 128
TSN::CJsonNode params = it.Val()["parameters"];
if(params.IsInvalid())
{
LogError(::StringFormat("Campo parametres no esta presente.. en pos = %d", it.m_cur), FUNCION_ACTUAL);
return false;
}
expected_len += (256 * 8) + (JsonObjStrLen(params, m_json.m_raw) * 3) + 128;
it.Next();
}
//---
SCRIPT_RESERVE_ARR(m_file_ind, m_file_ind_s, m_file_ind_r, expected_len)
//SCRIPT_RESERVE_ARR(m_file_pool, m_file_pool_s, m_file_pool_r, expected_len)
//--- Ahora si iteramos de verdad
it = indicators.BeginArr();
int curr_el = 0;
while(it.IsValid())
{
//--- Defoines de ayuda
#define SCRIPT_APPEND_CLASSNAME m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, class_name.StrStart(), class_name.StrLenRaw());
#define SCRIPT_APPEND_PADRE m_file_ind_s += ArrayCopy(m_file_ind, m_file_ind, m_file_ind_s, class_padre_start, class_padre_len);
//---
TSN::CJsonNode ind = it.Val();
//--- bloque inciia
SCRIPT_ADD_ONE_BLOCK(m_file_ind, m_file_ind_s)
//--- class
m_file_ind[m_file_ind_s++] = 'c';
m_file_ind[m_file_ind_s++] = 'l';
m_file_ind[m_file_ind_s++] = 'a';
m_file_ind[m_file_ind_s++] = 's';
m_file_ind[m_file_ind_s++] = 's';
m_file_ind[m_file_ind_s++] = ' ';
//---
TSN::CJsonNode class_name = ind["class_name"];
if(class_name.IsInvalid())
{
LogError(::StringFormat("No se encontro el campo class name en indicators[%d]", curr_el), FUNCION_ACTUAL);
return false;
}
//---
SCRIPT_APPEND_CLASSNAME
//---
const ulong num_buffers = ind["num_buffers"].ToUInt(0);
if(num_buffers == 0)
{
LogError(::StringFormat("indicators[%d], Clase = %s, proporicono un numero de buffers menor a 1", curr_el, class_name.ToString("")), FUNCION_ACTUAL);
return false;
}
//---
m_file_ind_s += ArrayCopy(m_file_ind, g_res_class_start, m_file_ind_s, 0); // public: padre
//--- Name CiIndicatorSimple<MQLA_B(algo)>
const int class_padre_start = m_file_ind_s;
m_file_ind_s += ArrayCopy(m_file_ind, g_res_class_p, m_file_ind_s, 0); // nombre
// ahora el buffer y cirrea
STRCONV_VALTOBUFFER_USIGNED(num_buffers, m_file_ind, m_file_ind_s)
m_file_ind[m_file_ind_s++] = ')';
m_file_ind[m_file_ind_s++] = '>';
const int class_padre_len = m_file_ind_s - class_padre_start;
//--- termiansmo la linea de class
SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s)
//---
SCRIPT_CTX(m_file_ind, m_file_ind_s, '{')
//--- public:\r\n
m_file_ind_s += ArrayCopy(m_file_ind, g_res_class_start, m_file_ind_s, RES_CLASS_START_OFF_PUBLIC, RES_CLASS_START_L_PUBLIC);
m_file_ind[m_file_ind_s++] = ':';
SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s)
//--- espacios para el contructor Class() :
m_file_ind_s += ArrayCopy(m_file_ind, g_res_contructor_start, m_file_ind_s, 0);
SCRIPT_APPEND_CLASSNAME
m_file_ind[m_file_ind_s++] = '(';
m_file_ind[m_file_ind_s++] = ')';
m_file_ind[m_file_ind_s++] = ' ';
m_file_ind[m_file_ind_s++] = ':';
//--- CiIndicatorSimple<MQL_A(buff)>()
SCRIPT_APPEND_PADRE
m_file_ind[m_file_ind_s++] = '(';
//--- Valor del contructor
TSN::CJsonNode type = ind["type"];
int ts, tl;
if((tl = type.StrLenRaw()) > 0 && m_json.m_raw[(ts = type.StrStart())] == '$')
{
ts++; // aumenta
tl--; // reduce el len
m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, ts, tl);
}
else
{
// solo numero enteoro no negaitvo asi que uint
const ulong type_n = type.ToUInt(ULONG_MAX);
if(type_n == ULONG_MAX)
{
LogError(::StringFormat("indicators[%d]: no se encontro el campo 'type' o el tipo debe de ser string (enum y emepzar con $)o un numero unsigned valido",
curr_el), FUNCION_ACTUAL);
return false;
}
STRCONV_VALTOBUFFER_USIGNED(type_n, m_file_ind, m_file_ind_s)
}
//--- finalziamos la linea del contrutro
m_file_ind_s += ArrayCopy(m_file_ind, g_res_fina_b, m_file_ind_s, 0);
//--- Ahora destructor
m_file_ind_s += ArrayCopy(m_file_ind, g_res_contructor_start, m_file_ind_s, 0);
m_file_ind[m_file_ind_s++] = '~';
SCRIPT_APPEND_CLASSNAME
m_file_ind[m_file_ind_s++] = '(';
m_file_ind_s += ArrayCopy(m_file_ind, g_res_fina_b, m_file_ind_s, 0);
//--- Funcion create (Firma)
m_file_ind_s += ArrayCopy(m_file_ind, g_res_create_func, m_file_ind_s, 0);
// Continuamos con la firma
m_file_ind_s += ArrayCopy(m_file_ind, g_res_initial_firm, m_file_ind_s, 0);
//---
TSN::CJsonNode parameters = ind["parameters"];
CJsonIteratorObj it_params = parameters.BeginObj();
while(it_params.IsValid())
{
//---
TSN::CJsonNode val = it_params.Val();
TSN::CJsonNode key = it_params.Key();
//---
m_file_ind[m_file_ind_s++] = ',';
m_file_ind[m_file_ind_s++] = ' ';
//---
if(val.GetType() != TSN::JSON_VTYPE_STRING)
{
LogError(::StringFormat("indiator[%d][parameter=%s] = Solo se permite strings como valores",
curr_el, it_params.Key().KeyToString()), FUNCION_ACTUAL);
return false;
}
//--- tipo name
m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, val.StrStart(), val.StrLenRaw());
m_file_ind[m_file_ind_s++] = ' ';
m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, key.StrStart(), key.KeyLenRaw());
//---
it_params.Next();
}
//--- Finalizamos
m_file_ind[m_file_ind_s++] = ')';
SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s)
// apertura del body
SCRIPT_CTX(m_file_ind, m_file_ind_s, '{')
m_file_ind_s += ArrayCopy(m_file_ind, g_res_hide_s, m_file_ind_s, 0); // Hide start
m_file_ind_s += ArrayCopy(m_file_ind, g_res_h_assing, m_file_ind_s, 0); // const int h = ::
// Ahora si el handle y parametros
//---
TSN::CJsonNode creator = ind["creator"];
if(creator.GetType() != TSN::JSON_VTYPE_STRING)
{
LogError(::StringFormat("indicator[%d][%s]: no se encontro el campo creator o este no es del tipo de string",
curr_el, class_name.ToString()), FUNCION_ACTUAL);
return false;
}
//---
m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, creator.StrStart(), creator.StrLenRaw()); // const int h = ::
m_file_ind_s += ArrayCopy(m_file_ind, g_res_create_h_ini, m_file_ind_s, 0);
//--- parametros
it_params = parameters.BeginObj();
while(it_params.IsValid())
{
TSN::CJsonNode key = it_params.Key();
m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, key.StrStart(), key.KeyLenRaw());
m_file_ind[m_file_ind_s++] = ',';
m_file_ind[m_file_ind_s++] = ' ';
it_params.Next();
}
//---
if(parameters.Size())
m_file_ind_s -= 2; // pop los finales
//---
m_file_ind[m_file_ind_s++] = ')';
m_file_ind[m_file_ind_s++] = ';';
SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s)
//---
m_file_ind_s += ArrayCopy(m_file_ind, g_res_body_ee, m_file_ind_s, 0); // Hide END
//--- Return:
m_file_ind_s += ArrayCopy(m_file_ind, g_res_return, m_file_ind_s, 0); // return
SCRIPT_APPEND_PADRE
m_file_ind_s += ArrayCopy(m_file_ind, g_res_ret_i_final, m_file_ind_s, 0); // return
//---
SCRIPT_CTX_WCLOSE(m_file_ind, m_file_ind_s) // cuerpo de clase
//---
it.Next();
curr_el++;
}
//---
#undef SCRIPT_APPEND_CLASSNAME
#undef SCRIPT_APPEND_PADRE
//---
if(m_file_ind_guard_s)
AddGuardEnd(m_file_ind, m_file_ind_s, m_file_ind_guard, 0, m_file_ind_guard_s);
//---
return true;
}
#endif // MQLARTICLES_INDICATORSCTS_IMP_INTERNLA_APP_MQH