forked from rosh/MQL5Book
472 lines
14 KiB
MQL5
472 lines
14 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| TradeBaseMonitor.mqh |
| |||
//| Copyright 2022, MetaQuotes Ltd. |
| |||
//| https://www.mql5.com |
| |||
//+------------------------------------------------------------------+
| |||
#include "EnumToArray.mqh"
| |||
#include "TradeUtils.mqh"
| |||
#include "Defines.mqh"
| |||
#include "TypeName.mqh"
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Common names for any of triple ENUMs used for properties types |
| |||
//+------------------------------------------------------------------+
| |||
enum PROP_TYPE
| |||
{
| |||
PROP_TYPE_INTEGER,
| |||
PROP_TYPE_DOUBLE,
| |||
PROP_TYPE_STRING,
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Base class for orders/deals/positions monitors (props viewer) |
| |||
//| Used by concrete monitors: |
| |||
//| #include "PositionMonitor.mqh" |
| |||
//| #include "DealMonitor.mqh" |
| |||
//| #include "OrderMonitor.mqh" |
| |||
//| Types I, D, S stand for 3 ENUM-types of properties |
| |||
//| I - integers, D - doubles, S - strings |
| |||
//+------------------------------------------------------------------+
| |||
template<typename I,typename D,typename S>
| |||
class MonitorInterface
| |||
{
| |||
protected:
| |||
bool ready;
| |||
| |||
template<typename E>
| |||
static bool detect(const int v)
| |||
{
| |||
ResetLastError();
| |||
const string s = EnumToString((E)v); // resulting string is not used
| |||
if(_LastError == 0) // only error code is important
| |||
{
| |||
return true;
| |||
}
| |||
return false;
| |||
}
| |||
| |||
template<typename E>
| |||
static int boundary(const E dummy = (E)NULL)
| |||
{
| |||
int values[];
| |||
const int n = EnumToArray(dummy, values, 0, 1000);
| |||
ArraySort(values);
| |||
return values[n - 1];
| |||
}
| |||
| |||
public:
| |||
| |||
class TradeState
| |||
{
| |||
static int indices[][2];
| |||
static int j, d, s;
| |||
public:
| |||
const static int limit;
| |||
| |||
static PROP_TYPE type(const int i)
| |||
{
| |||
return (PROP_TYPE)indices[i][0];
| |||
}
| |||
| |||
static int offset(const int i)
| |||
{
| |||
return indices[i][1];
| |||
}
| |||
| |||
static int size(const PROP_TYPE p)
| |||
{
| |||
switch(p)
| |||
{
| |||
case PROP_TYPE_INTEGER: return j;
| |||
case PROP_TYPE_DOUBLE: return d;
| |||
case PROP_TYPE_STRING: return s;
| |||
}
| |||
return 0;
| |||
}
| |||
| |||
static string enumname(const PROP_TYPE p)
| |||
{
| |||
switch(p)
| |||
{
| |||
case PROP_TYPE_INTEGER: return TYPENAME(I);
| |||
case PROP_TYPE_DOUBLE: return TYPENAME(D);
| |||
case PROP_TYPE_STRING: return TYPENAME(S);
| |||
}
| |||
return NULL;
| |||
}
| |||
| |||
static int calcIndices()
| |||
{
| |||
const int size = fmax(boundary<I>(),
| |||
fmax(boundary<D>(), boundary<S>())) + 1;
| |||
ArrayResize(indices, size);
| |||
j = d = s = 0;
| |||
for(int i = 0; i < size; ++i)
| |||
{
| |||
if(detect<I>(i))
| |||
{
| |||
indices[i][0] = PROP_TYPE_INTEGER;
| |||
indices[i][1] = j++;
| |||
}
| |||
else if(detect<D>(i))
| |||
{
| |||
indices[i][0] = PROP_TYPE_DOUBLE;
| |||
indices[i][1] = d++;
| |||
}
| |||
else if(detect<S>(i))
| |||
{
| |||
indices[i][0] = PROP_TYPE_STRING;
| |||
indices[i][1] = s++;
| |||
}
| |||
else
| |||
{
| |||
Print("Unresolved int value as enum: ", i, " for ", TYPENAME(TradeState));
| |||
indices[i][0] = -1;
| |||
indices[i][1] = -1;
| |||
}
| |||
}
| |||
| |||
return size;
| |||
}
| |||
| |||
long ulongs[];
| |||
double doubles[];
| |||
string strings[];
| |||
const MonitorInterface *owner;
| |||
| |||
TradeState(const MonitorInterface *ptr = NULL) : owner(ptr)
| |||
{
| |||
reset();
| |||
cache();
| |||
}
| |||
| |||
template<typename T>
| |||
void _get(const int e, T &value) const // overload with a reference of output value
| |||
{
| |||
if(owner)
| |||
{
| |||
value = owner.get(e, value);
| |||
}
| |||
else
| |||
{
| |||
switch(indices[e][0])
| |||
{
| |||
case PROP_TYPE_INTEGER: value = (T)ulongs[indices[e][1]]; break;
| |||
case PROP_TYPE_DOUBLE: value = (T)doubles[indices[e][1]]; break;
| |||
case PROP_TYPE_STRING: value = (T)strings[indices[e][1]]; break;
| |||
}
| |||
}
| |||
}
| |||
| |||
template<typename T>
| |||
T _get(const int e) const // read cache directly
| |||
{
| |||
T value = (T)NULL;
| |||
switch(indices[e][0])
| |||
{
| |||
case PROP_TYPE_INTEGER: value = (T)ulongs[indices[e][1]]; break;
| |||
case PROP_TYPE_DOUBLE: value = (T)doubles[indices[e][1]]; break;
| |||
case PROP_TYPE_STRING: value = (T)strings[indices[e][1]]; break;
| |||
}
| |||
return value;
| |||
}
| |||
| |||
template<typename T>
| |||
void _set(const int e, T value) const // write cache directly
| |||
{
| |||
switch(indices[e][0])
| |||
{
| |||
case PROP_TYPE_INTEGER: ulongs[indices[e][1]] = (long)value; break;
| |||
case PROP_TYPE_DOUBLE: doubles[indices[e][1]] = (double)value; break;
| |||
case PROP_TYPE_STRING: strings[indices[e][1]] = (string)value; break;
| |||
}
| |||
}
| |||
| |||
void cache()
| |||
{
| |||
for(int i = 0; i < limit; ++i)
| |||
{
| |||
switch(indices[i][0])
| |||
{
| |||
case PROP_TYPE_INTEGER: _get(i, ulongs[indices[i][1]]); break;
| |||
case PROP_TYPE_DOUBLE: _get(i, doubles[indices[i][1]]); break;
| |||
case PROP_TYPE_STRING: _get(i, strings[indices[i][1]]); break;
| |||
}
| |||
}
| |||
}
| |||
| |||
void reset()
| |||
{
| |||
ArrayResize(ulongs, j);
| |||
ArrayResize(doubles, d);
| |||
ArrayResize(strings, s);
| |||
| |||
ArrayInitialize(ulongs, 0);
| |||
ArrayInitialize(doubles, 0.0);
| |||
ArrayResize(strings, 0);
| |||
ArrayResize(strings, s);
| |||
}
| |||
};
| |||
| |||
| |||
MonitorInterface(): ready(false) { }
| |||
| |||
bool isReady() const
| |||
{
| |||
return ready;
| |||
}
| |||
| |||
template<typename E>
| |||
static string enumstr(const long v)
| |||
{
| |||
return EnumToString((E)v);
| |||
}
| |||
| |||
// all properties of type enum E (slow straightforward version)
| |||
template<typename E>
| |||
void list2log() const
| |||
{
| |||
E e = (E)0; // disable warning 'possible use of uninitialized variable'
| |||
int array[];
| |||
const int n = EnumToArray(e, array, 0, USHORT_MAX);
| |||
ResetLastError();
| |||
Print(TYPENAME(E), " Count=", n);
| |||
for(int i = 0; i < n; ++i)
| |||
{
| |||
e = (E)array[i];
| |||
PrintFormat("% 3d %s=%s", i, EnumToString(e), stringify(e));
| |||
}
| |||
}
| |||
| |||
// all properties of type enum I/D/S (fast indexed version)
| |||
void list2log(const PROP_TYPE super) const
| |||
{
| |||
Print(TradeState::enumname(super), " Count=", TradeState::size(super));
| |||
| |||
for(int k = 0, i = 0; k < TradeState::limit; ++k)
| |||
{
| |||
if(TradeState::type(k) == super)
| |||
{
| |||
switch(super)
| |||
{
| |||
case PROP_TYPE_INTEGER:
| |||
PrintFormat("% 3d %s=%s", i++, EnumToString((I)k), stringify((I)k));
| |||
break;
| |||
case PROP_TYPE_DOUBLE:
| |||
PrintFormat("% 3d %s=%s", i++, EnumToString((D)k), stringify((D)k));
| |||
break;
| |||
case PROP_TYPE_STRING:
| |||
PrintFormat("% 3d %s=%s", i++, EnumToString((S)k), stringify((S)k));
| |||
break;
| |||
}
| |||
}
| |||
}
| |||
}
| |||
| |||
// on false check _LastError for one of the following errors:
| |||
// - 4753 ERR_TRADE_POSITION_NOT_FOUND
| |||
// - 4754 ERR_TRADE_ORDER_NOT_FOUND
| |||
// - 4755 ERR_TRADE_DEAL_NOT_FOUND
| |||
// also 'ready' should be dropped to false
| |||
virtual bool refresh() = 0;
| |||
| |||
virtual void print() const
| |||
{
| |||
Print(TYPENAME(this), (ready ? "" : " not ready!"));
| |||
if(!ready) return;
| |||
list2log(PROP_TYPE_INTEGER);
| |||
list2log(PROP_TYPE_DOUBLE);
| |||
list2log(PROP_TYPE_STRING);
| |||
/*
| |||
list2log<I>();
| |||
list2log<D>();
| |||
list2log<S>();
| |||
*/
| |||
}
| |||
| |||
virtual long get(const I property) const = 0;
| |||
virtual double get(const D property) const = 0;
| |||
virtual string get(const S property) const = 0;
| |||
virtual long get(const int property, const long) const = 0;
| |||
virtual double get(const int property, const double) const = 0;
| |||
virtual string get(const int property, const string) const = 0;
| |||
| |||
virtual string stringify(const long v, const I property) const = 0;
| |||
| |||
virtual string stringify(const I property) const
| |||
{
| |||
return stringify(get(property), property);
| |||
}
| |||
| |||
virtual string stringify(const D property, const string format = NULL) const
| |||
{
| |||
if(format == NULL) return (string)get(property);
| |||
return StringFormat(format, get(property));
| |||
}
| |||
| |||
virtual string stringify(const S property) const
| |||
{
| |||
return get(property);
| |||
}
| |||
| |||
virtual string stringify(const int i) const
| |||
{
| |||
switch(TradeState::type(i))
| |||
{
| |||
case PROP_TYPE_INTEGER: return stringify((I)i);
| |||
case PROP_TYPE_DOUBLE: return stringify((D)i);
| |||
case PROP_TYPE_STRING: return stringify((S)i);
| |||
}
| |||
return NULL;
| |||
}
| |||
| |||
static string label(const int i)
| |||
{
| |||
switch(TradeState::type(i))
| |||
{
| |||
case PROP_TYPE_INTEGER: return EnumToString((I)i);
| |||
case PROP_TYPE_DOUBLE: return EnumToString((D)i);
| |||
case PROP_TYPE_STRING: return EnumToString((S)i);
| |||
}
| |||
return NULL;
| |||
}
| |||
| |||
bool operator==(const MonitorInterface &that) const
| |||
{
| |||
for(int i = 0; i < TradeState::limit; ++i)
| |||
{
| |||
switch(TradeState::type(i))
| |||
{
| |||
case PROP_TYPE_INTEGER:
| |||
if(this.get((I)i) != that.get((I)i)) return false;
| |||
break;
| |||
case PROP_TYPE_DOUBLE:
| |||
if(!TU::Equal(this.get((D)i), that.get((D)i))) return false;
| |||
break;
| |||
case PROP_TYPE_STRING:
| |||
if(this.get((S)i) != that.get((S)i)) return false;
| |||
break;
| |||
}
| |||
}
| |||
return true;
| |||
}
| |||
| |||
bool operator!=(const MonitorInterface &that) const
| |||
{
| |||
return !(this == that);
| |||
}
| |||
| |||
bool diff(const MonitorInterface &that, int &changes[])
| |||
{
| |||
int required[], r = 0;
| |||
if(ArraySize(changes) > 0) // optionally can request only part of properties
| |||
{
| |||
ArraySwap(required, changes);
| |||
ArraySort(required);
| |||
ResetLastError();
| |||
}
| |||
const int rtotal = ArraySize(required);
| |||
| |||
ArrayResize(changes, 0);
| |||
for(int i = 0; i < TradeState::limit; ++i)
| |||
{
| |||
if(rtotal > 0)
| |||
{
| |||
if(required[r] == i)
| |||
{
| |||
++r; // found, fall down to comparison and mark next property to find
| |||
}
| |||
else
| |||
{
| |||
continue; // skip if not required
| |||
}
| |||
}
| |||
| |||
switch(TradeState::type(i))
| |||
{
| |||
case PROP_TYPE_INTEGER:
| |||
if(this.get((I)i) != that.get((I)i))
| |||
{
| |||
PUSH(changes, i);
| |||
}
| |||
break;
| |||
case PROP_TYPE_DOUBLE:
| |||
if(!TU::Equal(this.get((D)i), that.get((D)i)))
| |||
{
| |||
PUSH(changes, i);
| |||
}
| |||
break;
| |||
case PROP_TYPE_STRING:
| |||
if(this.get((S)i) != that.get((S)i))
| |||
{
| |||
PUSH(changes, i);
| |||
}
| |||
break;
| |||
}
| |||
}
| |||
return ArraySize(changes) > 0;
| |||
}
| |||
| |||
bool operator==(const TradeState &that) const
| |||
{
| |||
for(int i = 0; i < TradeState::limit; ++i)
| |||
{
| |||
switch(TradeState::type(i))
| |||
{
| |||
case PROP_TYPE_INTEGER:
| |||
if(this.get((I)i) != that.ulongs[TradeState::offset(i)]) return false;
| |||
break;
| |||
case PROP_TYPE_DOUBLE:
| |||
if(!TU::Equal(this.get((D)i), that.doubles[TradeState::offset(i)])) return false;
| |||
break;
| |||
case PROP_TYPE_STRING:
| |||
if(this.get((S)i) != that.strings[TradeState::offset(i)]) return false;
| |||
break;
| |||
}
| |||
}
| |||
return true;
| |||
}
| |||
| |||
bool operator!=(const TradeState &that) const
| |||
{
| |||
return !(this == that);
| |||
}
| |||
| |||
bool diff(const TradeState &that, int &changes[])
| |||
{
| |||
ArrayResize(changes, 0);
| |||
for(int i = 0; i < TradeState::limit; ++i)
| |||
{
| |||
switch(TradeState::type(i))
| |||
{
| |||
case PROP_TYPE_INTEGER:
| |||
if(this.get((I)i) != that.ulongs[TradeState::offset(i)])
| |||
{
| |||
PUSH(changes, i);
| |||
}
| |||
break;
| |||
case PROP_TYPE_DOUBLE:
| |||
if(!TU::Equal(this.get((D)i), that.doubles[TradeState::offset(i)]))
| |||
{
| |||
PUSH(changes, i);
| |||
}
| |||
break;
| |||
case PROP_TYPE_STRING:
| |||
if(this.get((S)i) != that.strings[TradeState::offset(i)])
| |||
{
| |||
PUSH(changes, i);
| |||
}
| |||
break;
| |||
}
| |||
}
| |||
return ArraySize(changes) > 0;
| |||
}
| |||
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
template<typename I,typename D,typename S>
| |||
static int MonitorInterface::TradeState::indices[][2];
| |||
template<typename I,typename D,typename S>
| |||
static int MonitorInterface::TradeState::j, MonitorInterface::TradeState::d, MonitorInterface::TradeState::s;
| |||
template<typename I,typename D,typename S>
| |||
const static int MonitorInterface::TradeState::limit = MonitorInterface::TradeState::calcIndices();
|