371 行
11 KiB
MQL5
371 行
11 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| TradeFilter.mqh |
| |||
//| Copyright 2022, MetaQuotes Ltd. |
| |||
//| https://www.mql5.com |
| |||
//+------------------------------------------------------------------+
| |||
#include "MapArray.mqh"
| |||
#include "QuickSortTm.mqh"
| |||
#include "Defines.mqh"
| |||
#include "IS.mqh"
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Class for collecting orders/deals/positions and their properties |
| |||
//| if they match specific conditions. |
| |||
//| Type T should be one of: |
| |||
//| #include "PositionMonitor.mqh" |
| |||
//| #include "DealMonitor.mqh" |
| |||
//| #include "OrderMonitor.mqh" |
| |||
//+------------------------------------------------------------------+
| |||
template<typename T,typename I,typename D,typename S>
| |||
class TradeFilter
| |||
{
| |||
protected:
| |||
MapArray<ENUM_ANY,long> longs;
| |||
MapArray<ENUM_ANY,double> doubles;
| |||
MapArray<ENUM_ANY,string> strings;
| |||
MapArray<ENUM_ANY,IS> conditions;
| |||
| |||
static bool eps(const double v1, const double v2)
| |||
{
| |||
return fabs(v1 - v2) < DBL_EPSILON * fmax(v1, v2);
| |||
}
| |||
| |||
template<typename V>
| |||
static bool eps(const V v1, const V v2)
| |||
{
| |||
return false;
| |||
}
| |||
| |||
template<typename V>
| |||
static bool equal(const V v1, const V v2)
| |||
{
| |||
return v1 == v2 || eps(v1, v2);
| |||
}
| |||
| |||
template<typename V>
| |||
static bool greater(const V v1, const V v2)
| |||
{
| |||
return v1 > v2;
| |||
}
| |||
| |||
static bool bitwise_or(const long v1, const long v2)
| |||
{
| |||
return (((1 << v1) & v2) != 0);
| |||
}
| |||
| |||
static bool bitwise_or(const string v1, const string v2)
| |||
{
| |||
return false;
| |||
}
| |||
| |||
template<typename V>
| |||
static bool bitwise_or(const V v1, const V v2)
| |||
{
| |||
return false;
| |||
}
| |||
| |||
static bool equal(const string v1, const string v2)
| |||
{
| |||
if(StringFind(v2, "*") > -1)
| |||
{
| |||
int previous = 0;
| |||
string words[];
| |||
const int n = StringSplit(v2, '*', words);
| |||
for(int i = 0; i < n; ++i)
| |||
{
| |||
if(StringLen(words[i]) == 0) continue;
| |||
int index = StringFind(v1, words[i], previous);
| |||
if(index == -1)
| |||
{
| |||
return false;
| |||
}
| |||
previous = index + StringLen(words[i]);
| |||
}
| |||
return true;
| |||
}
| |||
return v1 == v2;
| |||
}
| |||
| |||
template<typename V>
| |||
bool match(const T &m, const MapArray<ENUM_ANY,V> &data) const
| |||
{
| |||
static const V type = (V)NULL;
| |||
int or_totals = 0, or_matches = 0;
| |||
for(int i = 0; i < data.getSize(); ++i)
| |||
{
| |||
const ENUM_ANY key = data.getKey(i);
| |||
switch(conditions[key])
| |||
{
| |||
case EQUAL_OR_ZERO:
| |||
if(equal(m.get(key, type), type))
| |||
{
| |||
continue; // zero is acceptable
| |||
}
| |||
// otherwise fallthrough
| |||
case EQUAL:
| |||
if(!equal(m.get(key, type), data.getValue(i)))
| |||
{
| |||
return false;
| |||
}
| |||
break;
| |||
case NOT_EQUAL:
| |||
if(equal(m.get(key, type), data.getValue(i)))
| |||
{
| |||
return false;
| |||
}
| |||
break;
| |||
case OR_EQUAL:
| |||
or_totals++;
| |||
if(equal(m.get(key, type), data.getValue(i)))
| |||
{
| |||
or_matches++;
| |||
}
| |||
break;
| |||
case OR_BITWISE:
| |||
if(!bitwise_or(m.get(key, type), data.getValue(i)))
| |||
{
| |||
return false;
| |||
}
| |||
break;
| |||
case GREATER:
| |||
if(!greater(m.get(key, type), data.getValue(i)))
| |||
{
| |||
return false;
| |||
}
| |||
break;
| |||
case LESS:
| |||
if(greater(m.get(key, type), data.getValue(i)))
| |||
{
| |||
return false;
| |||
}
| |||
break;
| |||
}
| |||
}
| |||
| |||
if(or_totals > 0) return or_matches > 0;
| |||
| |||
return true;
| |||
}
| |||
| |||
template<typename T1,typename U>
| |||
void sortTuple(U &data[], const T1 dummy) const
| |||
{
| |||
// we need aux array to keep track of original locations
| |||
// to reorder records according to new sequence
| |||
T1 array[][2];
| |||
const int p = ArraySize(data);
| |||
ArrayResize(array, p);
| |||
for(int i = 0; i < p; ++i)
| |||
{
| |||
array[i][0] = data[i]._1;
| |||
array[i][1] = (T1)i;
| |||
}
| |||
ArraySort(array);
| |||
U copy[];
| |||
// make a copy of original array and then
| |||
// place elements from it into original array on new locations
| |||
// ArrayCopy(copy, data); is not applicable for possible strings
| |||
ArrayResize(copy, p);
| |||
for(int i = 0; i < p; ++i)
| |||
{
| |||
copy[i] = data[i];
| |||
}
| |||
for(int i = 0; i < p; ++i)
| |||
{
| |||
data[i] = copy[(int)array[i][1]];
| |||
}
| |||
}
| |||
| |||
virtual int total() const = 0;
| |||
virtual ulong get(const int i) const = 0;
| |||
| |||
public:
| |||
TradeFilter *let(const I property, const long value, const IS cmp = EQUAL)
| |||
{
| |||
longs.put((ENUM_ANY)property, value);
| |||
conditions.put((ENUM_ANY)property, cmp);
| |||
return &this;
| |||
}
| |||
| |||
TradeFilter *let(const D property, const double value, const IS cmp = EQUAL)
| |||
{
| |||
doubles.put((ENUM_ANY)property, value);
| |||
conditions.put((ENUM_ANY)property, cmp);
| |||
return &this;
| |||
}
| |||
| |||
TradeFilter *let(const S property, const string value, const IS cmp = EQUAL)
| |||
{
| |||
strings.put((ENUM_ANY)property, value);
| |||
conditions.put((ENUM_ANY)property, cmp);
| |||
return &this;
| |||
}
| |||
| |||
template<typename E,typename V>
| |||
bool select(const E property, ulong &tickets[], V &data[], const bool sort = false) const
| |||
{
| |||
E properties[1] = {property};
| |||
V tuples[][1];
| |||
| |||
const bool result = select(properties, tickets, tuples, sort);
| |||
ArrayCopy(data, tuples);
| |||
return result;
| |||
}
| |||
| |||
// we need this overload because built-in ArraySort
| |||
// does not support arrays of strings
| |||
void ArraySort(string &s[][]) const
| |||
{
| |||
QuickSortTm<string> qt(s);
| |||
}
| |||
| |||
// a handy implementation of select for Tuples with shortened assign(m)
| |||
template<typename U> // U is expected to be a custom Tuple
| |||
bool select(U &data[], const bool sort = false) const
| |||
{
| |||
const int n = total();
| |||
ArrayResize(data, 0);
| |||
// loop through items
| |||
for(int i = 0; i < n; ++i)
| |||
{
| |||
const ulong t = get(i);
| |||
// access all properties via monitor
| |||
T m(t);
| |||
// check all filtering conditions
| |||
if(match(m, longs)
| |||
&& match(m, doubles)
| |||
&& match(m, strings))
| |||
{
| |||
// for a matching item, feed its properties into output array
| |||
const int k = EXPAND(data);
| |||
data[k].assign(m);
| |||
}
| |||
}
| |||
| |||
if(sort)
| |||
{
| |||
static const U u;
| |||
sortTuple(data, u._1);
| |||
}
| |||
| |||
return true;
| |||
}
| |||
| |||
template<typename U> // U is expected to be a Tuple<>, for example Tuple3<T1,T2,T3>
| |||
bool select(const int &property[], U &data[], const bool sort = false) const
| |||
{
| |||
const int q = ArraySize(property);
| |||
static const U u; // U::size() does not compile
| |||
if(q != u.size()) return false; // constraint
| |||
| |||
const int n = total();
| |||
ArrayResize(data, 0);
| |||
// loop through items
| |||
for(int i = 0; i < n; ++i)
| |||
{
| |||
const ulong t = get(i);
| |||
// access all properties via monitor
| |||
T m(t);
| |||
// check all filtering conditions
| |||
if(match(m, longs)
| |||
&& match(m, doubles)
| |||
&& match(m, strings))
| |||
{
| |||
// for a matching item, feed its properties into output array
| |||
const int k = EXPAND(data);
| |||
data[k].assign(property, m);
| |||
}
| |||
}
| |||
| |||
if(sort)
| |||
{
| |||
sortTuple(data, u._1);
| |||
}
| |||
| |||
return true;
| |||
}
| |||
| |||
| |||
template<typename E,typename V>
| |||
bool select(const E &property[], ulong &tickets[], V &data[][], const bool sort = false) const
| |||
{
| |||
// size of array with properties must match output tuple size
| |||
const int q = ArrayRange(data, 1);
| |||
if(ArraySize(property) != q) return false; // error
| |||
| |||
const int n = total();
| |||
ArrayResize(tickets, 0);
| |||
ArrayResize(data, 0);
| |||
// loop through items
| |||
for(int i = 0; i < n; ++i)
| |||
{
| |||
const ulong t = get(i);
| |||
// access all properties via monitor
| |||
T m(t);
| |||
// check all filtering conditions
| |||
if(match(m, longs)
| |||
&& match(m, doubles)
| |||
&& match(m, strings))
| |||
{
| |||
// for a matching item, feed its ticket and properties into output arrays
| |||
const int k = EXPAND(data);
| |||
for(int j = 0; j < q; ++j)
| |||
{
| |||
data[k][j] = m.get(property[j]);
| |||
}
| |||
PUSH(tickets, t);
| |||
}
| |||
}
| |||
| |||
if(sort)
| |||
{
| |||
// we need aux array to keep track of original locations
| |||
// to reorder records according to new sequence
| |||
V array[][2];
| |||
const int p = ArrayRange(data, 0);
| |||
ArrayResize(array, p);
| |||
for(int i = 0; i < p; ++i)
| |||
{
| |||
array[i][0] = data[i][0];
| |||
array[i][1] = (V)i;
| |||
}
| |||
ArraySort(array);
| |||
ulong temp[];
| |||
V array2d[];
| |||
// make a flat copy of original array and then
| |||
// place elements from it into original array on new locations
| |||
ArrayCopy(array2d, data);
| |||
for(int i = 0; i < p; ++i)
| |||
{
| |||
const int k = (int)array[i][1];
| |||
PUSH(temp, tickets[k]);
| |||
for(int j = 0; j < q; ++j)
| |||
{
| |||
data[i][j] = array2d[k * q + j];
| |||
}
| |||
}
| |||
ArraySwap(tickets, temp);
| |||
}
| |||
| |||
return true;
| |||
}
| |||
| |||
bool select(ulong &tickets[]) const
| |||
{
| |||
const int n = total();
| |||
ArrayResize(tickets, 0);
| |||
for(int i = 0; i < n; ++i)
| |||
{
| |||
const ulong t = get(i);
| |||
T m(t);
| |||
if(match(m, longs)
| |||
&& match(m, doubles)
| |||
&& match(m, strings))
| |||
{
| |||
PUSH(tickets, t);
| |||
}
| |||
}
| |||
return ArraySize(tickets) > 0;
| |||
}
| |||
};
| |||
//+------------------------------------------------------------------+
|