FileReadStruct

Lit du fichier binaire le contenu à la structure transmise à titre du paramètre. La lecture est produite de la position courante de l'indicateur de fichier.

uint  FileReadStruct(
   int          file_handle,        // handle du fichier
   const void&  struct_object,      // structure, où la lecture est faite
   int          size=-1             // dimension de la structure en bytes
   );

Paramètres

file_handle

[in]   Le descripteur de fichier du fichier binaire ouvert.

struct_object

[out]  L'objet de la structure indiquée. La structure ne doit pas contenir les chaînes, les tableaux dynamiques et les fonctions virtuelles.

size=-1

[in]  Le nombre de bytes, lesquels il faut lire. Si la dimension n'est pas spécifiée ou le nombre de bytes plus que la taille de la structure est indiqué, on utilise la dimension exacte de la structure indiquée.

La valeur rendue

En cas de succès la fonction rend le nombre de bytes lus. L'indicateur de fichier est déplacé par le même nombre de bytes.

Exemple (on utilise le fichier reçu à la suite du travail de l'exemple pour la fonction FileWriteStruct)

//+------------------------------------------------------------------+
//|                                          Demo_FileReadStruct.mq5 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_plots   1
//---- plot Label1
#property indicator_label1  "Candles"
#property indicator_type1   DRAW_CANDLES
#property indicator_color1  clrOrange
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
#property indicator_separate_window
//--- les paramètres pour la réception des données
input string  InpFileName="EURUSD.txt"// le nom du fichier
input string  InpDirectoryName="Data";  // le nom du répertoire
//+------------------------------------------------------------------+
//| La structure pour la sauvegarde des données de la bougie                               |
//+------------------------------------------------------------------+
struct candlesticks
  {
   double            open;  // le prix de l'ouverture
   double            close; // le prix de la clôture
   double            high;  // le prix maximum
   double            low;   // le prix minimum
   datetime          date;  // la date
  };
//--- les tampons d'indicateur
double       open_buff[];
double       close_buff[];
double       high_buff[];
double       low_buff[];
//--- les variables globales
candlesticks cand_buff[];
int          size=0;
int          ind=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   int default_size=100;
   ArrayResize(cand_buff,default_size);
//--- ouvrons le fichier
   ResetLastError();
   int file_handle=FileOpen(InpDirectoryName+"//"+InpFileName,FILE_READ|FILE_BIN|FILE_COMMON);
   if(file_handle!=INVALID_HANDLE)
     {
      PrintFormat("Le fichier %s est ouvert pour la lecture",InpFileName);
      PrintFormat("La voie vers le fichier: %s\\Files\\",TerminalInfoString(TERMINAL_COMMONDATA_PATH));
      //--- lisons les données du fichier
      while(!FileIsEnding(file_handle))
        {
         //--- inscrirons les données au tableau
         FileReadStruct(file_handle,cand_buff[size]);
         size++;
         //--- vérifier un tableau sur l'encombrement
         if(size==default_size)
           {
            //---augmentons la dimension du tableau
            default_size+=100;
            ArrayResize(cand_buff,default_size);
           }
        }
      //--- fermons le fichier
      FileClose(file_handle);
      PrintFormat("Les données sont lues, le fichier %s est fermé",InpFileName);
     }
   else
     {
      PrintFormat("On n' a pas réussi à ouvrir le fichier %s, le code de l'erreur = %d",InpFileName,GetLastError());
      return(INIT_FAILED);
     }
//--- indicator buffers mapping
   SetIndexBuffer(0,open_buff,INDICATOR_DATA);
   SetIndexBuffer(1,high_buff,INDICATOR_DATA);
   SetIndexBuffer(2,low_buff,INDICATOR_DATA);
   SetIndexBuffer(3,close_buff,INDICATOR_DATA);
//--- une valeur vide
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   ArraySetAsSeries(time,false);
//--- le cycle pour les bougies pas encore traitées
   for(int i=prev_calculated;i<rates_total;i++)
     {
      //--- par défaut 0
      open_buff[i]=0;
      close_buff[i]=0;
      high_buff[i]=0;
      low_buff[i]=0;
      //---la vérification s'il y a encore des données
      if(ind<size)
        {
         for(int j=ind;j<size;j++)
           {
            //--- si les dates correspondent, utilisons la valeur du fichier
            if(time[i]==cand_buff[j].date)
              {
               open_buff[i]=cand_buff[j].open;
               close_buff[i]=cand_buff[j].close;
               high_buff[i]=cand_buff[j].high;
               low_buff[i]=cand_buff[j].low;
               //--- augmentons le compteur
               ind=j+1;
               break;
              }
           }
        }
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Voir aussi

Les structures et les classes, FileWriteStruct