Programación en MQL5 para tradersHerramientas lingüísticas avanzadasCalendario económicoFiltrar eventos por múltiples condiciones

Download in one file:

MQL5 Algo Book in PDF

MQL5 Algo Book in CHM

Filtrar eventos por múltiples condiciones

Como sabemos por las secciones anteriores de este capítulo, la API de MQL5 permite solicitar eventos de calendario en función de varias condiciones:

por países (CalendarValueHistory, CalendarValueLast)
por frecuencias (CalendarValueHistory, CalendarValueLast)
por ID de tipo de evento (CalendarValueHistoryByEvent, CalendarValueLastByEvent)
por intervalo de tiempo (CalendarValueHistory, CalendarValueHistoryByEvent)
por cambios desde la encuesta del calendario anterior (CalendarValueLast, CalendarValueLastByEvent)
por ID de noticia específica (CalendarValueById)

Esto se puede resumir en la siguiente tabla de funciones (de todas las funciones de CalendarValue, aquí sólo falta CalendarValueById para obtener un valor específico).

Condiciones	Intervalo de tiempo	Últimos cambios
Países	CalendarValueHistory	CalendarValueLast
Divisas	CalendarValueHistory	CalendarValueLast
Eventos	CalendarValueHistoryByEvent	CalendarValueLastByEvent

Este conjunto de herramientas abarca los principales escenarios de análisis de calendarios, aunque no todos. Por lo tanto, en la práctica, a menudo es necesario implementar mecanismos de filtrado personalizados en MQL5, incluyendo, en concreto, las solicitudes de eventos por:

varios países
varias divisas
varios tipos de eventos
valores de propiedades arbitrarias de los eventos (importancia, sector de la economía, periodo de referencia, tipo, presencia de una previsión, impacto estimado en la tasa, subcadena en el nombre del evento, etc.)

Para resolver estos problemas, hemos creado la clase CalendarFilter (CalendarFilter.mqh).

Debido a las especificidades de las funciones integradas de la API, algunos de los atributos de las noticias tienen mayor prioridad que el resto. Esto incluye el país, la divisa y el intervalo de fechas. Se pueden especificar en el constructor de la clase, y entonces la propiedad correspondiente no se puede cambiar dinámicamente en las condiciones del filtro.

Esto se debe a que la clase de filtro se ampliará posteriormente con las capacidades de almacenamiento en caché de noticias para permitir la lectura desde el probador, y las condiciones iniciales del constructor en realidad definen el contexto de almacenamiento en caché dentro del cual es posible el filtrado posterior. Por ejemplo, si al crear un objeto especificamos el código de país «UE», obviamente no tiene sentido solicitar a través de él noticias sobre Estados Unidos o Brasil. Esto es similar al intervalo de fechas: especificarlo en el constructor hará imposible recibir noticias fuera del intervalo.

También podemos crear un objeto sin condiciones iniciales (porque todos los parámetros del constructor son opcionales), y entonces será capaz de almacenar en caché y filtrar noticias en toda la base de datos del calendario (en el momento de guardarlo).

Además, dado que los países y las divisas se muestran ahora de forma casi única (con la excepción de la Unión Europea y EUR), se pasan al constructor a través de un único parámetro context: si se especifica una cadena con una longitud de 2 caracteres, el código del país (o una combinación de países) está implícito, y si la longitud es de 3 caracteres, el código de la moneda está implícito. Para los códigos «UE» y «EUR», la zona del euro es un subconjunto de la «UE» (dentro de los países con tratados formales). En casos especiales, en los que interesan países de la UE no pertenecientes a la zona euro, también pueden describirse en el contexto de «UE». Si es necesario pueden añadirse al filtro condiciones más estrictas para las noticias sobre las divisas de estos países (BGN, HUF, DKK, ISK, PLN, RON, HRK, CZK, SEK) de forma dinámica utilizando métodos que presentaremos más adelante. No obstante, debido a condiciones exóticas, no hay garantías de que esas noticias entren en el calendario.

Empecemos a estudiar la clase.

class CalendarFilter
{
protected:
   // initial (optional) conditions set in the constructor, invariants
   string context;    // country and currency
   datetime from, to; // date range
   bool fixedDates;   // if 'from'/'to' are passed in the constructor, they cannot be changed

   // dedicated selectors (countries/currencies/event type identifiers)
   string country[], currency[];
   ulong ids[];

   MqlCalendarValue values[]; // filtered results

   virtual void init()
   {
      fixedDates = from != 0 || to != 0;
      if(StringLen(context) == 3)
      {
         PUSH(currency, context);
      }
      else
      {
         // even if context is NULL, we take it to poll the entire calendar base
         PUSH(country, context);
      }
   }
   ...
public:
   CalendarFilter(const string _context = NULL,
      const datetime _from = 0, const datetime _to = 0):
      context(_context), from(_from), to(_to)
   {
      init();
   }
   ...

Se asignan dos arrays para los países y las divisad: country y currency. Si no se rellenan desde context durante la creación del objeto, el programa MQL podrá añadir condiciones para varios países o divisas con el fin de realizar una consulta de noticias combinada en ellos.

Para almacenar las condiciones de todos los demás atributos de las noticias, el array selectors se describe en el objeto CalendarFilter, con la segunda dimensión igual a 3. Podemos decir que se trata de un tipo de tabla en la que cada fila tiene 3 columnas.

long selectors[][3]; // [0] - property, [1] - value, [2] - condition

En el índice 0 se localizarán los identificadores de las propiedades de las noticias. Dado que los atributos están repartidos en tres tablas base (MqlCalendarCountry, MqlCalendarEvent, MqlCalendarValue) se describen utilizando los elementos de la enumeración generalizada ENUM_CALENDAR_PROPERTY (CalendarDefines.mqh).

enum ENUM_CALENDAR_PROPERTY
{                                      // +/- means support for field filtering
   CALENDAR_PROPERTY_COUNTRY_ID,       // -ulong
   CALENDAR_PROPERTY_COUNTRY_NAME,     // -string
   CALENDAR_PROPERTY_COUNTRY_CODE,     // +string (2 characters)
   CALENDAR_PROPERTY_COUNTRY_CURRENCY, // +string (3 characters)
   CALENDAR_PROPERTY_COUNTRY_GLYPH,    // -string (1 characters)
   CALENDAR_PROPERTY_COUNTRY_URL,      // -string

   CALENDAR_PROPERTY_EVENT_ID,         // +ulong (event type ID)
   CALENDAR_PROPERTY_EVENT_TYPE,       // +ENUM_CALENDAR_EVENT_TYPE
   CALENDAR_PROPERTY_EVENT_SECTOR,     // +ENUM_CALENDAR_EVENT_SECTOR
   CALENDAR_PROPERTY_EVENT_FREQUENCY,  // +ENUM_CALENDAR_EVENT_FREQUENCY
   CALENDAR_PROPERTY_EVENT_TIMEMODE,   // +ENUM_CALENDAR_EVENT_TIMEMODE
   CALENDAR_PROPERTY_EVENT_UNIT,       // +ENUM_CALENDAR_EVENT_UNIT
   CALENDAR_PROPERTY_EVENT_IMPORTANCE, // +ENUM_CALENDAR_EVENT_IMPORTANCE
   CALENDAR_PROPERTY_EVENT_MULTIPLIER, // +ENUM_CALENDAR_EVENT_MULTIPLIER
   CALENDAR_PROPERTY_EVENT_DIGITS,     // -uint
   CALENDAR_PROPERTY_EVENT_SOURCE,     // +string ("http[s]://")
   CALENDAR_PROPERTY_EVENT_CODE,       // -string
   CALENDAR_PROPERTY_EVENT_NAME,       // +string (4+ characters or wildcard '*')

   CALENDAR_PROPERTY_RECORD_ID,        // -ulong
   CALENDAR_PROPERTY_RECORD_TIME,      // +datetime
   CALENDAR_PROPERTY_RECORD_PERIOD,    // +datetime (like long)
   CALENDAR_PROPERTY_RECORD_REVISION,  // +int
   CALENDAR_PROPERTY_RECORD_ACTUAL,    // +long
   CALENDAR_PROPERTY_RECORD_PREVIOUS,  // +long
   CALENDAR_PROPERTY_RECORD_REVISED,   // +long
   CALENDAR_PROPERTY_RECORD_FORECAST,  // +long
   CALENDAR_PROPERTY_RECORD_IMPACT,    // +ENUM_CALENDAR_EVENT_IMPACT

   CALENDAR_PROPERTY_RECORD_PREVISED,  // +non-standard (previous or revised if any)

   CALENDAR_PROPERTY_CHANGE_ID,        // -ulong (reserved)
};

El índice 1 almacenará valores para compararlos con ellos en las condiciones de selección de registros de noticias. Por ejemplo, si desea establecer un filtro por sector de la economía, entonces escribimos CALENDAR_PROPERTY_EVENT_SECTOR en selectors[i][0] y uno de los valores de la enumeración estándar ENUM_CALENDAR_EVENT_SECTOR en selectors[i][1].

Por último, la última columna (bajo el 2º índice) está reservada a la operación de comparación del valor del selector con el valor del atributo de la noticia: todas las operaciones admitidas se resumen en la enumeración IS.

enum IS
{
   EQUAL,
   NOT_EQUAL,
   GREATER,
   LESS,
   OR_EQUAL,
   ...
};

Vimos un planteamiento similar en TradeFilter.mqh. Así, podremos establecer condiciones no sólo para la igualdad de valores, sino también para la desigualdad o las relaciones más/menos. Por ejemplo, es fácil imaginar un filtro en el campo CALENDAR_PROPERTY_EVENT_IMPORTANCE, que debería ser MAYOR que CALENDAR_IMPORTANCE_LOW (se trata de un elemento de la enumeración estándar ENUM_CALENDAR_EVENT_IMPORTANCE), lo que significa una selección de noticias de importancia media y alta.

La siguiente enumeración definida específicamente para el calendario es ENUM_CALENDAR_SCOPE. Dado que el filtrado de calendarios suele asociarse a intervalos de tiempo, aquí se enumeran los más solicitados.

#define DAY_LONG     (60 * 60 * 24)
#define WEEK_LONG    (DAY_LONG * 7)
#define MONTH_LONG   (DAY_LONG * 30)
#define QUARTER_LONG (MONTH_LONG * 3)
#define YEAR_LONG    (MONTH_LONG * 12)

enum ENUM_CALENDAR_SCOPE
{
   SCOPE_DAY = DAY_LONG,         // Day
   SCOPE_WEEK = WEEK_LONG,       // Week
   SCOPE_MONTH = MONTH_LONG,     // Month
   SCOPE_QUARTER = QUARTER_LONG, // Quarter
   SCOPE_YEAR = YEAR_LONG,       // Year
};

Todas las enumeraciones se colocan en un archivo de encabezado independiente CalendarDefines.mqh.

Pero volvamos a la clase CalendarFilter. El tipo del array selectors es long, que es adecuado para almacenar valores de casi todos los tipos implicados: enumeraciones, fechas y horas, identificadores, números enteros e incluso valores de indicadores económicos porque se almacenan en el calendario en forma de números long (en millonésimas de valores reales). Sin embargo, ¿qué hacer con las propiedades de las cadenas?

Este problema se resuelve utilizando el array de cadenas stringCache, a la que se añadirán todas las líneas mencionadas en las condiciones del filtro.

class CalendarFilter
{
protected:
   ...
   string stringCache[];  // cache of all rows in 'selectors'
   ...

Entonces, en lugar del valor de la cadena en selectors[i][1], podemos guardar fácilmente el índice de un elemento en el array stringCache.

Para rellenar el array selectors con las condiciones de filtrado, se proporcionan varios métodos let, en concreto, para las enumeraciones:

class CalendarFilter
{
...
public:
   // all fields of enum types are processed here
   template<typename E>
   CalendarFilter *let(const E e, const IS c = EQUAL)
   {
      const int n = EXPAND(selectors);
      selectors[n][0] = resolve(e); // by type E, returning the element ENUM_CALENDAR_PROPERTY
      selectors[n][1] = e;
      selectors[n][2] = c;
      return &this;
   }
   ...

Para los valores reales de los indicadores:

   // the following fields are processed here:
   // CALENDAR_PROPERTY_RECORD_ACTUAL, CALENDAR_PROPERTY_RECORD_PREVIOUS,
   // CALENDAR_PROPERTY_RECORD_REVISED, CALENDAR_PROPERTY_RECORD_FORECAST,
   // and CALENDAR_PROPERTY_RECORD_PERIOD (as long)
   CalendarFilter *let(const long value, const ENUM_CALENDAR_PROPERTY property, const IS c = EQUAL)
   {
      const int n = EXPAND(selectors);
      selectors[n][0] = property;
      selectors[n][1] = value;
      selectors[n][2] = c;
      return &this;
   }
   ...

Y para las cadenas:

   // conditions for all string properties can be found here (abbreviated)
   CalendarFilter *let(const string find, const IS c = EQUAL)
   {
      const int wildcard = (StringFind(find, "*") + 1) * 10;
      switch(StringLen(find) + wildcard)
      {
      case 2:
         // if the initial context is different from the country, we can supplement it with the country,
         // otherwise the filter is ignored
         if(StringLen(context) != 2)
         {
            if(ArraySize(country) == 1 && StringLen(country[0]) == 0)
            {
               country[0] = find; // narrow down "all countries" to one (may add more)
            }
            else
            {
               PUSH(country, find);
            }
         }
         break;
      case 3:
         // we can set a filter for a currency only if it was not in the initial context
         if(StringLen(context) != 3)
         {
            PUSH(currency, find);
         }
         break;
      default:
         {
            const int n = EXPAND(selectors);
            PUSH(stringCache, find);
            if(StringFind(find, "http://") == 0 || StringFind(find, "https://") == 0)
            {
               selectors[n][0] = CALENDAR_PROPERTY_EVENT_SOURCE;
            }
            else
            {
               selectors[n][0] = CALENDAR_PROPERTY_EVENT_NAME;
            }
            selectors[n][1] = ArraySize(stringCache) - 1;
            selectors[n][2] = c;
            break;
         }
      }

      return &this;
   }

En la sobrecarga del método para cadenas, observe que las cadenas largas de 2 o 3 caracteres (si no llevan el asterisco de plantilla '*', que es un sustituto de una secuencia arbitraria de caracteres) entran en los arrays de países y símbolos, respectivamente, y todas las demás cadenas se tratan como fragmentos del nombre o de la fuente de noticias, y en ambos campos intervienen stringCache y selectors.

De forma especial, la clase también admite el filtrado por tipo (identificador) de eventos.

protected:
   ulong ids[];           // filtered event types
   ...
public:
   CalendarFilter *let(const ulong event)
   {
      PUSH(ids, event);
      return &this;
   }
   ...

Así, el número de filtros prioritarios (que se procesan fuera del array de selectores) incluye no sólo países, divisas e intervalos de fechas, sino también identificadores de tipo de evento. Esta decisión constructiva se debe a que estos parámetros pueden pasarse como entrada a determinadas funciones de la API de calendario. Obtenemos todos los demás atributos de las noticias como valores de campo de salida en arrays de estructuras (MqlCalendarValue, MqlCalendarEvent, MqlCalendarCountry). Es por ellos que realizaremos el filtrado adicional, de acuerdo con las reglas en el array de selectores.

Todos los métodos de let devuelven un puntero a un objeto, lo que permite encadenar sus llamadas. Por ejemplo, así:

CalendarFilter f;
f.let(CALENDAR_IMPORTANCE_LOW, GREATER) // important and moderately important news
  .let(CALENDAR_TIMEMODE_DATETIME) // only events with exact time
  .let("DE").let("FR") // a couple of countries, or, to choose from...
  .let("USD").let("GBP") // ...a couple of currencies (but both conditions won't work at once)
  .let(TimeCurrent() - MONTH_LONG, TimeCurrent() + WEEK_LONG) // date range "around" the current time
  .let(LONG_MIN, CALENDAR_PROPERTY_RECORD_FORECAST, NOT_EQUAL) // there is a forecast
  .let("farm"); // full text search by news titles

Las condiciones del país y de la divisa pueden, en teoría, combinarse. No obstante, tenga en cuenta que los valores múltiples sólo pueden establecerse para países o divisas, pero no para ambos. Uno de estos dos aspectos del contexto (cualquiera de los dos) en la implementación actual sólo admite uno o ninguno de los valores (es decir, no tiene filtro). Por ejemplo, si se selecciona la divisa EUR, es posible limitar el contexto de búsqueda a las noticias de Alemania y Francia (códigos de país «DE» y «FR»). En consecuencia, se descartarán las noticias del BCE y de Eurostat, así como, en concreto, las de Italia y España. No obstante, la indicación de EUR en este caso es redundante, ya que no existen otras divisas en Alemania y Francia.

Dado que la clase utiliza funciones integradas en las que los parámetros country y currency se aplican a las noticias mediante la operación lógica AND, compruebe la coherencia de las condiciones de filtrado.

Una vez que el código de llamada establece las condiciones de filtrado, es necesario seleccionar las noticias en función de ellas. Esto es lo que hace el método público select (dado con simplificaciones).

public:
   bool select(MqlCalendarValue &result[])
   {
      int count = 0;
      ArrayFree(result);
      if(ArraySize(ids)) // identifiers of event types
      {
         for(int i = 0; i < ArraySize(ids); ++i)
         {
            MqlCalendarValue temp[];
            if(PRTF(CalendarValueHistoryByEvent(ids[i], temp, from, to)))
            {
               ArrayCopy(result, temp, ArraySize(result));
               ++count;
            }
         }
      }
      else
      {
         // several countries or currencies, choose whichever is more as a basis,
         // only the first element from the smaller array is used
         if(ArraySize(country) > ArraySize(currency))
         {
            const string c = ArraySize(currency) > 0 ? currency[0] : NULL;
            for(int i = 0; i < ArraySize(country); ++i)
            {
               MqlCalendarValue temp[];
               if(PRTF(CalendarValueHistory(temp, from, to, country[i], c)))
               {
                  ArrayCopy(result, temp, ArraySize(result));
                  ++count;
               }
            }
         }
         else
         {
            const string c = ArraySize(country) > 0 ? country[0] : NULL;
            for(int i = 0; i < ArraySize(currency); ++i)
            {
               MqlCalendarValue temp[];
               if(PRTF(CalendarValueHistory(temp, from, to, c, currency[i])))
               {
                  ArrayCopy(result, temp, ArraySize(result));
                  ++count;
               }
            }
         }
      }

      if(ArraySize(result) > 0)
      {
         filter(result);
      }

      if(count > 1 && ArraySize(result) > 1)
      {
         SORT_STRUCT(MqlCalendarValue, result, time);
      }

      return ArraySize(result) > 0;
   }

Dependiendo de cuál de los arrays de atributos de prioridad esté lleno, el método llama a diferentes funciones de la API para sondear el calendario:

Si el array ids está lleno, se llama a CalendarValueHistoryByEvent en un bucle para todos los identificadores
Si el array country está lleno y es mayor que el array de divisas, llame a CalendarValueHistory y recorra los países mediante un bucle.
Si el array currency está lleno y es mayor o igual que el tamaño del array de países, llame a CalendarValueHistory y recorra las divisas mediante un bucle.

Cada llamada a una función rellena un array temporal de estructuras MqlCalendarValue temp[], que se acumula secuencialmente en el array de parámetros result. Después de escribir en él todas las noticias relevantes según las condiciones principales (fechas, países, divisas, identificadores), si las hay, entra en juego un método auxiliar filter, que filtra el array basándose en las condiciones de selectors. Al final del método select, las noticias se clasifican por orden cronológico, que puede romperse combinando los resultados de varias consultas de las funciones «calendario». La ordenación se lleva a cabo mediante la macro SORT_STRUCT, de la que ya se habló en la sección Comparar, ordenar y buscar en arrays.

Para cada elemento del array de noticias, el método filter llama al método match, que devuelve un indicador booleano de si la noticia coincide con las condiciones del filtro. En caso contrario, el elemento se elimina del array.

protected:
   void filter(MqlCalendarValue &result[])
   {
      for(int i = ArraySize(result) - 1; i >= 0; --i)
      {
         if(!match(result[i]))
         {
            ArrayRemove(result, i, 1);
         }
      }
   }
   ...

Por último, el método match analiza nuestro array selectors y la compara con los campos de la estructura pasada MqlCalendarValue. Aquí se proporciona el código de forma abreviada.

bool match(const MqlCalendarValue &v)
   {
      MqlCalendarEvent event;
      if(!CalendarEventById(v.event_id, event)) return false;

      // loop through all filter conditions, except for countries, currencies, dates, IDs,
      // which have already been previously used when calling Calendar functions
      for(int j = 0; j < ArrayRange(selectors, 0); ++j)
      {
         long field = 0;
         string text = NULL;

         // get the field value from the news or its description
         switch((int)selectors[j][0])
         {
         case CALENDAR_PROPERTY_EVENT_TYPE:
            field = event.type;
            break;
         case CALENDAR_PROPERTY_EVENT_SECTOR:
            field = event.sector;
            break;
         case CALENDAR_PROPERTY_EVENT_TIMEMODE:
            field = event.time_mode;
            break;
         case CALENDAR_PROPERTY_EVENT_IMPORTANCE:
            field = event.importance;
            break;
         case CALENDAR_PROPERTY_EVENT_SOURCE:
            text = event.source_url;
            break;
         case CALENDAR_PROPERTY_EVENT_NAME:
            text = event.name;
            break;
         case CALENDAR_PROPERTY_RECORD_IMPACT:
            field = v.impact_type;
            break;
         case CALENDAR_PROPERTY_RECORD_ACTUAL:
            field = v.actual_value;
            break;
         case CALENDAR_PROPERTY_RECORD_PREVIOUS:
            field = v.prev_value;
            break;
         case CALENDAR_PROPERTY_RECORD_REVISED:
            field = v.revised_prev_value;
            break;
         case CALENDAR_PROPERTY_RECORD_PREVISED: // previous or revised (if any)
            field = v.revised_prev_value != LONG_MIN ? v.revised_prev_value : v.prev_value;
            break;
         case CALENDAR_PROPERTY_RECORD_FORECAST:
            field = v.forecast_value;
            break;
         ...
         }

         // compare value with filter condition
         if(text == NULL) // numeric fields
         {
            switch((IS)selectors[j][2])
            {
            case EQUAL:
               if(!equal(field, selectors[j][1])) return false;
               break;
            case NOT_EQUAL:
               if(equal(field, selectors[j][1])) return false;
               break;
            case GREATER:
               if(!greater(field, selectors[j][1])) return false;
               break;
            case LESS:
               if(greater(field, selectors[j][1])) return false;
               break;
            }
         }
         else // string fields
         {
            const string find = stringCache[(int)selectors[j][1]];
            switch((IS)selectors[j][2])
            {
            case EQUAL:
               if(!equal(text, find)) return false;
               break;
            case NOT_EQUAL:
               if(equal(text, find)) return false;
               break;
            case GREATER:
               if(!greater(text, find)) return false;
               break;
            case LESS:
               if(greater(text, find)) return false;
               break;
            }
         }
      }

      return true;
   }

Los métodos equal y greater copian casi por completo los utilizados en nuestros desarrollos anteriores con clases de filtros.

En este caso, el problema de filtrado se resuelve en general, es decir, el programa MQL puede utilizar el objeto CalendarFilter de la siguiente manera:

CalendarFilter f;
f.let()... // a series of calls to the let method to set filtering conditions
MqlCalendarValue records[];
if(f.select(records))
{
ArrayPrint(records);
}

De hecho, el método select puede hacer algo más importante que dejamos para un estudio opcional independiente.

En primer lugar, en la lista de noticias resultante, conviene insertar de algún modo un separador (delimiter) entre el pasado y el futuro, para que el ojo lo capte. En teoría, esta característica es extremadamente importante para los calendarios, pero por alguna razón, no está disponible en la interfaz de usuario de MetaTrader 5 y en el sitio web mql5.com. Nuestra implementación es capaz de insertar una estructura vacía entre el pasado y el futuro, que debemos mostrar visualmente (de lo que nos ocuparemos a continuación).

En segundo lugar, el tamaño del array resultante puede ser bastante grande (especialmente en las primeras etapas de selección de ajustes), por lo que el método select ofrece además la posibilidad de limitar el tamaño del array (limit). Para ello, se eliminan los elementos más alejados de la hora actual.

Así, el prototipo completo del método tiene este aspecto:

bool select(MqlCalendarValue &result[],
const bool delimiter = false, const int limit = -1);

Por defecto, no se inserta ningún delimitador y el array no se trunca.

Un par de párrafos más arriba mencionamos una subtarea adicional del filtrado que es la visualización del array resultante. La clase CalendarFilter tiene un método especial format, que convierte el array de estructuras pasado MqlCalendarValue &data[] en un array de cadenas legibles string &result[]. El código del método se encuentra en el archivo adjunto CalendarFilter.mqh.

bool format(const MqlCalendarValue &data[],
const ENUM_CALENDAR_PROPERTY &props[], string &result[],
const bool padding = false, const bool header = false);

Los campos de MqlCalendarValue que queremos mostrar se especifican en el array props. Recordemos que la enumeración ENUM_CALENDAR_PROPERTY contiene campos de las tres estructuras de calendario dependientes para que un programa MQL pueda mostrar automáticamente no sólo los indicadores económicos de un registro de evento concreto, sino también su nombre, características, país o código de divisa. Todo ello se implementa mediante el método format.

Cada fila del array de salida result contiene una representación textual del valor de uno de los campos (número, descripción, elemento de enumeración). El tamaño del array result es igual al producto del número de estructuras en la entrada (en data) y el número de campos visualizados (en props). El parámetro opcional header permite añadir una fila con los nombres de los campos (columnas) al principio del array de salida. El parámetro padding controla la generación de espacios adicionales en el texto para que sea conveniente mostrar la tabla en un tipo de letra monoespaciado (por ejemplo, en una revista).

La clase CalendarFilter tiene otro método público importante: update.

bool update(MqlCalendarValue &result[]);

Su estructura repite casi por completo select. Sin embargo, en lugar de llamar a las funciones CalendarValueHistoryByEvent y CalendarValueHistory, el método llama a CalendarValueLastByEvent y CalendarValueLast. El propósito del método es obvio: consulta el calendario en busca de cambios recientes que coincidan con las condiciones de filtrado. Pero para su funcionamiento requiere una identificación de los cambios. Dicho campo sí está definido en la clase: la primera vez se rellena dentro del método select.

class CalendarFilter
{
protected:
   ...
   ulong change;
   ...
public:
   bool select(MqlCalendarValue &result[],
      const bool delimiter = false, const int limit = -1)
   {
      ...
      change = 0;
      MqlCalendarValue dummy[];
      CalendarValueLast(change, dummy);
      ...
   }

Algunos matices de la clase CalendarFilter todavía están «tras el telón», pero abordaremos algunos de ellos en las siguientes secciones.

Probemos el filtro en acción: primero en un sencillo script CalendarFilterPrint.mq5 y después en un indicador más práctico CalendarMonitor.mq5.

En los parámetros de entrada del script puede establecer el contexto (código de país o divisa), el intervalo de tiempo y la cadena para la búsqueda de texto completo por nombres de eventos, así como limitar el tamaño de la tabla de noticias resultante.

input string Context; // Context (country - 2 characters, currency - 3 characters, empty - no filter)
input ENUM_CALENDAR_SCOPE Scope = SCOPE_MONTH;
input string Text = "farm";
input int Limit = -1;

Dados los parámetros, se crea un objeto filtro global.

CalendarFilter f(Context, TimeCurrent() - Scope, TimeCurrent() + Scope);

A continuación, en OnStart, configuramos un par de condiciones constantes adicionales (importancia media y alta de los eventos) y la presencia de una previsión (el campo no es igual a LONG_MIN), así como el paso y una cadena de búsqueda al objeto.

void OnStart()
{
   f.let(CALENDAR_IMPORTANCE_LOW, GREATER)
      .let(LONG_MIN, CALENDAR_PROPERTY_RECORD_FORECAST, NOT_EQUAL)
      .let(Text); // with '*' replacement support
      // NB: strings with the character length of 2 or 3 without '*' will be treated
      // as a country or currency code, respectively

A continuación, se llama al método select y el array resultante de estructuras MqlCalendarValue se formatea en una tabla con 9 columnas utilizando el método format.

MqlCalendarValue records[];
   // apply the filter conditions and get the result
   if(f.select(records, true, Limit))
   {
      static const ENUM_CALENDAR_PROPERTY props[] =
      {
         CALENDAR_PROPERTY_RECORD_TIME,
         CALENDAR_PROPERTY_COUNTRY_CURRENCY,
         CALENDAR_PROPERTY_EVENT_NAME,
         CALENDAR_PROPERTY_EVENT_IMPORTANCE,
         CALENDAR_PROPERTY_RECORD_ACTUAL,
         CALENDAR_PROPERTY_RECORD_FORECAST,
         CALENDAR_PROPERTY_RECORD_PREVISED,
         CALENDAR_PROPERTY_RECORD_IMPACT,
         CALENDAR_PROPERTY_EVENT_SECTOR,
      };
      static const int p = ArraySize(props);

      // output the formatted result
      string result[];
      if(f.format(records, props, result, true, true))
      {
         for(int i = 0; i < ArraySize(result) / p; ++i)
         {
            Print(SubArrayCombine(result, " | ", i * p, p));
         }
      }
   }
}

Las celdas de la tabla se unen en filas y se envían al registro.

Con la configuración por defecto (es decir, para todos los países y divisas, con la parte «granja» en el nombre de los eventos de importancia media y alta), puede obtener algo como este calendario.

Selecting calendar records...

country[i]= / ok

calendarValueHistory(temp,from,to,country[i],c)=2372 / ok

Filtering 2372 records

Got 9 records

2022.06.02 15:15 | USD | ADP Nonfarm Employment Change | HIGH | +128 | -225 | +202 | POSITIVE | JOBS

2022.06.02 15:30 | USD | Nonfarm Productivity q/q | MODERATE | -7.3 | -7.5 | -7.5 | POSITIVE | JOBS

2022.06.03 15:30 | USD | Nonfarm Payrolls | HIGH | +390 | -19 | +436 | POSITIVE | JOBS

2022.06.03 15:30 | USD | Private Nonfarm Payrolls | MODERATE | +333 | +8 | +405 | POSITIVE | JOBS

2022.06.09 08:30 | EUR | Nonfarm Payrolls q/q | MODERATE | +0.3 | +0.3 | +0.3 | NA | JOBS

– | – | – | – | – | – | – | – | –

2022.07.07 15:15 | USD | ADP Nonfarm Employment Change | HIGH | +nan | -263 | +128 | NA | JOBS

2022.07.08 15:30 | USD | Nonfarm Payrolls | HIGH | +nan | -229 | +390 | NA | JOBS

2022.07.08 15:30 | USD | Private Nonfarm Payrolls | MODERATE | +nan | +51 | +333 | NA | JOBS

Ahora echemos un vistazo al indicador CalendarMonitor.mq5. Su objetivo es mostrar al usuario la selección actual de eventos en el gráfico de acuerdo con los filtros especificados. Para visualizar la tabla, utilizaremos la ya conocida clase de marcador (Tableau.mqh, véase la sección Cálculo del margen para una orden futura). El indicador no tiene búferes ni gráficos.

Los parámetros de entrada permiten establecer el rango de la ventana de tiempo (scope), así como el contexto global para el objeto CalendarFilter, que es la divisa o el código de país en Context (vacío por defecto, es decir, sin restricciones) o mediante una bandera booleana UseChartCurrencies. Está activada por defecto, y se recomienda utilizarla para recibir automáticamente noticias de aquellas divisas que conforman la herramienta de trabajo del gráfico.

input string Context; // Context (country - 2 chars, currency - 3 chars, empty - all)
input ENUM_CALENDAR_SCOPE Scope = SCOPE_WEEK;
input bool UseChartCurrencies = true;

Se pueden aplicar filtros adicionales por tipo de evento, sector y gravedad.

input ENUM_CALENDAR_EVENT_TYPE_EXT Type = TYPE_ANY;
input ENUM_CALENDAR_EVENT_SECTOR_EXT Sector = SECTOR_ANY;
input ENUM_CALENDAR_EVENT_IMPORTANCE_EXT Importance = IMPORTANCE_MODERATE; // Importance (at least)

La importancia establece el límite inferior de la selección, no la coincidencia exacta. Así, el valor por defecto de IMPORTANCE_MODERATE captará no sólo la importancia moderada, sino también la alta.

Un lector atento observará que aquí se utilizan enumeraciones desconocidas: ENUM_CALENDAR_EVENT_TYPE_EXT, ENUM_CALENDAR_EVENT_SECTOR_EXT, ENUM_CALENDAR_EVENT_IMPORTANCE_EXT. Se encuentran en el archivo ya mencionado CalendarDefines.mqh, y coinciden (casi uno a uno) con enumeraciones integradas similares. La única diferencia es que han añadido un elemento que significa «cualquier» valor. Necesitamos describir tales enumeraciones para simplificar la introducción de condiciones: ahora el filtro de cada campo se configura mediante una lista desplegable en la que se puede seleccionar uno de los valores o desactivar el filtro. Si no fuera por el elemento de enumeración añadido, tendríamos que introducir una bandera lógica «on/off» en la interfaz para cada campo.

Además, los parámetros de entrada permiten consultar los eventos por la presencia en ellos de indicadores reales, de previsión y anteriores, así como por la búsqueda de una cadena de texto (Text).

input string Text;
input ENUM_CALENDAR_HAS_VALUE HasActual = HAS_ANY;
input ENUM_CALENDAR_HAS_VALUE HasForecast = HAS_ANY;
input ENUM_CALENDAR_HAS_VALUE HasPrevious = HAS_ANY;
input ENUM_CALENDAR_HAS_VALUE HasRevised = HAS_ANY;
input int Limit = 30;

Los objetos CalendarFilter y tableau se describen a nivel global.

CalendarFilter f(Context);
AutoPtr<Tableau> t;

Tenga en cuenta que el filtro se crea una vez, mientras que la tabla está representada por un autoselector y se volverá a crear dinámicamente en función del tamaño de los datos recibidos.

La configuración de los filtros se realiza en OnInit mediante llamadas consecutivas a los métodos de let en función de los parámetros de entrada.

int OnInit()
{
   if(!f.isLoaded()) return INIT_FAILED;

   if(UseChartCurrencies)
   {
      const string base = SymbolInfoString(_Symbol, SYMBOL_CURRENCY_BASE);
      const string profit = SymbolInfoString(_Symbol, SYMBOL_CURRENCY_PROFIT);
      f.let(base);
      if(base != profit)
      {
         f.let(profit);
      }
   }

   if(Type != TYPE_ANY)
   {
      f.let((ENUM_CALENDAR_EVENT_TYPE)Type);
   }

   if(Sector != SECTOR_ANY)
   {
      f.let((ENUM_CALENDAR_EVENT_SECTOR)Sector);
   }

   if(Importance != IMPORTANCE_ANY)
   {
      f.let((ENUM_CALENDAR_EVENT_IMPORTANCE)(Importance - 1), GREATER);
   }

   if(StringLen(Text))
   {
      f.let(Text);
   }

   if(HasActual != HAS_ANY)
   {
      f.let(LONG_MIN, CALENDAR_PROPERTY_RECORD_ACTUAL,
         HasActual == HAS_SET ? NOT_EQUAL : EQUAL);
   }
   ...

   EventSetTimer(1);

   return INIT_SUCCEEDED;
}

Al final, se pone en marcha un segundo temporizador. Todo el trabajo se realiza en OnTimer.

void OnTimer()
{
   static const ENUM_CALENDAR_PROPERTY props[] = // table columns
   {
      CALENDAR_PROPERTY_RECORD_TIME,
      CALENDAR_PROPERTY_COUNTRY_CURRENCY,
      CALENDAR_PROPERTY_EVENT_NAME,
      CALENDAR_PROPERTY_EVENT_IMPORTANCE,
      CALENDAR_PROPERTY_RECORD_ACTUAL,
      CALENDAR_PROPERTY_RECORD_FORECAST,
      CALENDAR_PROPERTY_RECORD_PREVISED,
      CALENDAR_PROPERTY_RECORD_IMPACT,
      CALENDAR_PROPERTY_EVENT_SECTOR,
   };
   static const int p = ArraySize(props);

   MqlCalendarValue records[];

almost one to one   f.let(TimeCurrent() - Scope, TimeCurrent() + Scope); // shift the time window every time

   const ulong trackID = f.getChangeID();
   if(trackID) // if the state has already been removed, check for changes
   {
      if(f.update(records)) // request changes by filters
      {
         // if there are changes, notify the user
         string result[];
         f.format(records, props, result);
         for(int i = 0; i < ArraySize(result) / p; ++i)
         {
            Alert(SubArrayCombine(result, " | ", i * p, p));
         }
      // "fall through" further to update the table
      }
      else if(trackID == f.getChangeID())
      {
         return; // calendar without changes
      }
   }

   // request a complete set of news by filters
   f.select(records, true, Limit);

   // display the news table on the chart
   string result[];
   f.format(records, props, result, true, true);

   if(t[] == NULL || t[].getRows() != ArraySize(records) + 1)
   {
      t = new Tableau("CALT", ArraySize(records) + 1, p,
         TBL_CELL_HEIGHT_AUTO, TBL_CELL_WIDTH_AUTO,
         Corner, Margins, FontSize, FontName, FontName + " Bold",
         TBL_FLAG_ROW_0_HEADER,
         BackgroundColor, BackgroundTransparency);
   }
   const string hints[] = {};
   t[].fill(result, hints);
}

Si ejecutamos el indicador en el gráfico EURUSD con la configuración predeterminada, podemos obtener la siguiente imagen.

Noticias filtradas y formateadas en el gráfico

Seguimiento de los cambios de eventos por tipo

Transferir la base de datos de calendarios al probador