MQLArticles/Utils/File/File.mqh

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

//|                                                         File.mqh |

//|                                  Copyright 2026, Niquel Mendoza. |

//|                          https://www.mql5.com/es/users/nique_372 |

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

#property copyright "Copyright 2026, Niquel Mendoza."

#property link      "https://www.mql5.com/es/users/nique_372"

#property strict



#ifndef MQLARTICLES_UTILS_FILE_FILE_MQH

#define MQLARTICLES_UTILS_FILE_FILE_MQH



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

//|                                                                  |

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

#include "..\\Basic.mqh"



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

//| Csv                                                              |

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

string get_header(string _filename)

 {

  int _fh = FileOpen(_filename, FILE_ANSI | FILE_COMMON | FILE_CSV | FILE_READ, "\n");

  string header = FileReadString(_fh);

  FileClose(_fh);

  return header;

 }



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

int numero_lineas_csv(string _filename)

 {

  int lineas = 0;

  int _fh = FileOpen(_filename, FILE_ANSI | FILE_COMMON | FILE_CSV | FILE_READ, "\n");

  while(!FileIsEnding(_fh))

   {

    FileReadString(_fh);

    lineas++;

   }

  FileClose(_fh);

  return lineas;

 }



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

int numero_columnas_csv(string _filename)

 {

  int _fh = FileOpen(_filename, FILE_ANSI | FILE_COMMON | FILE_CSV | FILE_READ, "\n");

  string linea = FileReadString(_fh);

  string columnas[];

  StringSplit(linea, ',', columnas);

  FileClose(_fh);

  return ArraySize(columnas);

 }



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

//| Data del csv                                                     |

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

string ExtractCSVColumn(string file_name, int col_index, ushort separator = ',')

 {

  string result = "";

  string sym = ShortToString(separator);

// Abrir el archivo CSV en modo lectura

  int handle = FileOpen(file_name, FILE_READ | FILE_CSV);

  if(handle == INVALID_HANDLE)

   {

    Print(__FUNCTION__, "::Error al abrir el archivo: ", file_name);

    return "";

   }



// Leer el archivo l<EFBFBD>nea por l<EFBFBD>nea hasta el final

  while(!FileIsEnding(handle))

   {

    string line = FileReadString(handle);



    // Dividir la l<EFBFBD>nea por comas en un arreglo de strings

    string columns[];

    int count = StringSplit(line, separator, columns);



    // Verificar que la columna deseada exista en esta l<EFBFBD>nea

    if(count > col_index)

     {

      // Si ya hay contenido en 'result', se a<EFBFBD>ade una coma como separador

      if(result != "")

        result += sym;

      result += columns[col_index];

     }

   }



  FileClose(handle);

  return result;

 }



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

struct file_data_csv

 {

private:

  string             file_cabezera;

  int                file_handle;

  string             file_name;

  bool               create;



public:



  void               Create(string new_file_name, string cabezera, int open_flags = FILE_WRITE | FILE_CSV | FILE_COMMON)

   {

    this.file_name = new_file_name;

    this.file_cabezera = cabezera;

    this.file_handle =  FileOpen(this.file_name, open_flags);

    create = true;

    if(this.file_handle == INVALID_HANDLE)

     {

      Print(__FUNCTION__"::Error al abrir el archivo: ", this.file_name, ", ultimo error: ", GetLastError());

     }

    FileWrite(this.file_handle, cabezera);

   };

  inline string      GetFileName()

   {

    return this.file_name;

   }

  inline void        Close()

   {

    FileClose(this.file_handle);

   }

  inline void        Write(string text)

   {

    FileWrite(this.file_handle, text);

   }

 };



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

void DeleteFileWithChecks(string fileName, int commonFlag = FILE_COMMON)

 {

  ResetLastError();



// Comprobar si el archivo existe en la ubicaci<EFBFBD>n especificada

  if(FileIsExist(fileName, commonFlag))

   {

    // Intentar eliminar el archivo

    if(FileDelete(fileName, commonFlag))

     {

      // Confirmaci<EFBFBD>n de que el archivo fue eliminado

      Print("Archivo '", fileName, "' eliminado correctamente.");

     }

    else

     {

      // Informar del error al intentar eliminar el archivo

      int errCode = GetLastError();

      Print("Error al eliminar el archivo '", fileName, "'. C<00>digo de error: ", errCode);

     }

   }

  else

   {

    // El archivo no existe, informar al usuario

    Print("El archivo '", fileName, "' no existe en la ubicaci<00>n especificada.");

   }

 }



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

void RenameFileWithChecks(const string oldFileName, int commonFlag, const string newFileName, int modeFlags)

 {

// Comprobar si el archivo original existe

  if(FileIsExist(oldFileName, commonFlag))

   {

    // Intentar cambiar el nombre del archivo

    if(FileMove(oldFileName, commonFlag, newFileName, modeFlags))

     {

      // Confirmaci<EFBFBD>n de que el nombre del archivo fue cambiado

      Print("El archivo '", oldFileName, "' ha sido renombrado a '", newFileName, "' correctamente.");

     }

    else

     {

      // Informar del error al intentar cambiar el nombre del archivo

      int errCode = GetLastError();

      Print("Error al cambiar el nombre del archivo de '", oldFileName, "' a '", newFileName, "'. C<00>digo de error: ", errCode);

     }

   }

  else

   {

    // El archivo no existe, informar al usuario

    Print("El archivo '", oldFileName, "' no existe en la ubicaci<00>n especificada.");

   }

 }





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

struct Filas

 {

  string             datos[];

 };



//---

struct CSV

 {

  Filas              data[];

 };



//---

bool CSVToArray(const string &fileName, bool common_flag, CSV &file, ushort line_separator, uint code_page = CP_ACP)

 {

// Limpia el array existente

  ArrayResize(file.data, 0);



  int flags = common_flag ? FILE_COMMON : 0;



// Verifica que el archivo exista

  if(!FileIsExist(fileName, flags))

   {

    printf("%s:: El archivo %s no existe", __FUNCTION__, fileName);

    return false; // Sale de la funci<EFBFBD>n si el archivo no existe

   }



  flags = !common_flag  ? (FILE_READ | FILE_CSV) : (FILE_READ | FILE_CSV | FILE_COMMON);



  ResetLastError();

// Abre el archivo en modo lectura

  const int fileHandle = FileOpen(fileName, flags, "\n", code_page);

  if(fileHandle == INVALID_HANDLE)

   {

    Print(__FUNCTION__, ":: Error al abrir el archivo: ", fileName, " | ultimo error: ", GetLastError());

    return false; // Sale de la funci<EFBFBD>n si no se puede abrir el archivo

   }



// Lee el archivo l<EFBFBD>nea por l<EFBFBD>nea

  while(!FileIsEnding(fileHandle))

   {

    const string line = FileReadString(fileHandle);

    if(StringLen(line) > 0)

     {



      ArrayResize(file.data, file.data.Size() + 1);

      string linea[];

      StringSplit(line, line_separator, linea);



      ArrayResize(file.data[file.data.Size() - 1].datos, linea.Size());



      for(int i = 0; i < ArraySize(linea) ; i++)

        file.data[file.data.Size() - 1].datos[i] = linea[i];



     }

   }



// Cierra el archivo

  printf("%s:: Exito al cargar el archivo %s, numero de filas %d", __FUNCTION__, fileName, ArraySize(file.data));

  FileClose(fileHandle);

  return true;

 }





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

//|                                                                  |

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

bool CSVToMatrix(string fileName,

                 matrix& out_mtx,

                 bool common_flag,

                 bool file_have_header,

                 ushort line_separator,

                 string &out_header)

 {

// Limpia el array existente

  out_mtx.Resize(0, 0);



// Verifica que el archivo exista