1920 lines
No EOL
106 KiB
MQL5
1920 lines
No EOL
106 KiB
MQL5
#ifndef MAX_ORDERS
|
|
#define DELETE_MACRO_MAX_ORDERS
|
|
#define MAX_ORDERS 200 // https://www.mql5.com/ru/forum/282062/page66#comment_55114313
|
|
#endif // #ifndef MAX_ORDERS
|
|
|
|
#ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
#define VIRTUAL_ORDERSELECT_MACROS(A, B) B
|
|
#else // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
#define VIRTUAL_ORDERSELECT_MACROS(A, B) A
|
|
#endif // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY #else
|
|
|
|
// https://www.mql5.com/ru/forum/1111/page2336#comment_9660624
|
|
// Нужно для BestInterval
|
|
// #define TICKS_CORRECT_TIME // время тиков, кратное секунде, будет скорректировано на миллисекунду вперед
|
|
// https://www.mql5.com/ru/forum/321656/page34#comment_14192799
|
|
// #define TICKS_FORCE_NORMALIZE // Принудительная нормализация цен входящего тика
|
|
|
|
#include "HistoryOrders.mqh"
|
|
|
|
#ifdef __MQL5__
|
|
#ifndef SELECT_BY_POS
|
|
#define SELECT_BY_POS 0
|
|
#endif // SELECT_BY_POS
|
|
|
|
#ifndef SELECT_BY_TICKET
|
|
#define SELECT_BY_TICKET 1
|
|
#endif // SELECT_BY_TICKET
|
|
|
|
#ifndef MODE_TRADES
|
|
#define MODE_TRADES 0
|
|
#endif // MODE_TRADES
|
|
|
|
#ifndef MODE_HISTORY
|
|
#define MODE_HISTORY 1
|
|
#endif // MODE_HISTORY
|
|
|
|
#ifndef OP_SELL
|
|
#define OP_SELL ORDER_TYPE_SELL
|
|
#endif // OP_SELL
|
|
#endif // __MQL5__
|
|
|
|
typedef void (*STRATEGY)( void );
|
|
typedef void (*STRATEGY_MULTI)( const string &Symb, const int &Index );
|
|
|
|
class ORDERS : public HISTORYORDERS
|
|
{
|
|
private:
|
|
bool Netting;
|
|
|
|
protected: // SNAPSHOT::Snaphot - VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
int SelectIndex;
|
|
|
|
private:
|
|
int PrevAmountOrders;
|
|
|
|
string ID;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
// На предыдущем тике была вызвана функция из этого списка:
|
|
// -OrderProfit, -OrderClosePrice, -AccountEquity, -AccountProfit, -OrderPrint
|
|
// +OrderSend, +OrderModify, +OrderClose, +OrderDelete, +OrderCloseBy.
|
|
bool CallFunc;
|
|
|
|
bool CallChange; // На текущем тике вызван this.IsChange().
|
|
|
|
struct PRICEBORDERS
|
|
{
|
|
private:
|
|
int Flag;
|
|
|
|
struct MINMAX
|
|
{
|
|
double Min;
|
|
double Max;
|
|
|
|
void SetMax( const double &Price )
|
|
{
|
|
if (Price && (Price < this.Max))
|
|
this.Max = Price;
|
|
|
|
return;
|
|
}
|
|
|
|
void SetMin(const double &Price )
|
|
{
|
|
if (Price > this.Min)
|
|
this.Min = Price;
|
|
|
|
return;
|
|
}
|
|
|
|
bool IsAccept( const double &Price ) const
|
|
{
|
|
return((Price <= this.Min) || (Price >= this.Max));
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
this.Min = 0;
|
|
this.Max = DBL_MAX;
|
|
|
|
return;
|
|
}
|
|
} bid, ask;
|
|
|
|
void Calc( const ORDER &Order )
|
|
{
|
|
switch (Order.Type)
|
|
{
|
|
case ORDER_TYPE_BUY:
|
|
this.bid.SetMax(Order.TakeProfit);
|
|
this.bid.SetMin(Order.StopLoss);
|
|
|
|
break;
|
|
case ORDER_TYPE_SELL:
|
|
this.ask.SetMin(Order.TakeProfit);
|
|
this.ask.SetMax(Order.StopLoss);
|
|
|
|
break;
|
|
case ORDER_TYPE_BUY_LIMIT:
|
|
this.ask.SetMin(Order.OpenPrice);
|
|
|
|
break;
|
|
case ORDER_TYPE_SELL_LIMIT:
|
|
this.bid.SetMax(Order.OpenPrice);
|
|
|
|
break;
|
|
case ORDER_TYPE_BUY_STOP:
|
|
this.ask.SetMax(Order.OpenPrice);
|
|
|
|
break;
|
|
case ORDER_TYPE_SELL_STOP:
|
|
this.bid.SetMin(Order.OpenPrice);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
this.bid.Init();
|
|
this.ask.Init();
|
|
|
|
return;
|
|
}
|
|
|
|
void SetFlag( void )
|
|
{
|
|
// Приоритет на лимитники и TP.
|
|
// static const string Condition[] = {"(Tick.bid >= this.bid.Max)", "(Tick.ask <= this.ask.Min)",
|
|
// "(Tick.bid <= this.bid.Min)", "(Tick.ask >= this.ask.Max)"};
|
|
|
|
// https://www.mql5.com/ru/forum/170952/page238#comment_51197092
|
|
|
|
// Приоритет на стоповые и SL.
|
|
// static const string Condition[] = {"(Tick.bid <= this.bid.Min)", "(Tick.ask >= this.ask.Max)",
|
|
// "(Tick.bid >= this.bid.Max)", "(Tick.ask <= this.ask.Min)"};
|
|
|
|
// Приоритет на лимитники и TP.
|
|
this.Flag = (this.bid.Max != DBL_MAX) | ((this.ask.Min != 0) << 1) |
|
|
((this.bid.Min != 0) << 2) | ((this.ask.Max != DBL_MAX) << 3);
|
|
|
|
return;
|
|
}
|
|
|
|
bool IsAccept2( const MqlTick &Tick ) const
|
|
{
|
|
// Приоритет на лимитники и TP.
|
|
switch (this.Flag)
|
|
{
|
|
case 0:
|
|
return(false);
|
|
case 1:
|
|
return(Tick.bid >= this.bid.Max);
|
|
case 2:
|
|
return(Tick.ask <= this.ask.Min);
|
|
case 3:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.ask <= this.ask.Min));
|
|
case 4:
|
|
return(Tick.bid <= this.bid.Min);
|
|
case 5:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.bid <= this.bid.Min));
|
|
case 6:
|
|
return((Tick.ask <= this.ask.Min) || (Tick.bid <= this.bid.Min));
|
|
case 7:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.ask <= this.ask.Min) || (Tick.bid <= this.bid.Min));
|
|
case 8:
|
|
return(Tick.ask >= this.ask.Max);
|
|
case 9:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.ask >= this.ask.Max));
|
|
case 10:
|
|
return((Tick.ask <= this.ask.Min) || (Tick.ask >= this.ask.Max));
|
|
case 11:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.ask <= this.ask.Min) || (Tick.ask >= this.ask.Max));
|
|
case 12:
|
|
return((Tick.bid <= this.bid.Min) || (Tick.ask >= this.ask.Max));
|
|
case 13:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.bid <= this.bid.Min) || (Tick.ask >= this.ask.Max));
|
|
case 14:
|
|
return((Tick.ask <= this.ask.Min) || (Tick.bid <= this.bid.Min) || (Tick.ask >= this.ask.Max));
|
|
case 15:
|
|
return((Tick.bid >= this.bid.Max) || (Tick.ask <= this.ask.Min) || (Tick.bid <= this.bid.Min) || (Tick.ask >= this.ask.Max));
|
|
}
|
|
|
|
return(false);
|
|
}
|
|
|
|
public:
|
|
bool Ready;
|
|
|
|
void Set( const ORDER &Orders[], const int &Total )
|
|
{
|
|
_VC
|
|
|
|
this.Init();
|
|
|
|
for (uint i = Total; (bool)i--;)
|
|
this.Calc(Orders[i]);
|
|
|
|
this.SetFlag(); // См. this.IsAccept()
|
|
|
|
this.Ready = true;
|
|
|
|
return;
|
|
}
|
|
|
|
bool IsAccept( const MqlTick &Tick )
|
|
{
|
|
_VC
|
|
|
|
// const bool Res = this.bid.IsAccept(Tick.bid) || this.ask.IsAccept(Tick.ask); // this.SetFlag() не нужен.
|
|
const bool Res = this.IsAccept2(Tick);
|
|
|
|
if (Res)
|
|
this.Ready = false;
|
|
|
|
return(Res);
|
|
}
|
|
} PriceBorders;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
static string GetTickFlag( uint tickflag )
|
|
{
|
|
string flag = " " + (string)tickflag;
|
|
|
|
#define TICKFLAG_MACRO(A) flag += ((bool)(tickflag & TICK_FLAG_##A)) ? " TICK_FLAG_" + #A : ""; \
|
|
tickflag -= tickflag & TICK_FLAG_##A;
|
|
TICKFLAG_MACRO(BID)
|
|
TICKFLAG_MACRO(ASK)
|
|
TICKFLAG_MACRO(LAST)
|
|
TICKFLAG_MACRO(VOLUME)
|
|
TICKFLAG_MACRO(BUY)
|
|
TICKFLAG_MACRO(SELL)
|
|
#undef TICKFLAG_MACRO
|
|
|
|
if (tickflag)
|
|
flag += " FLAG_UNKNOWN (" + (string)tickflag + ")";
|
|
|
|
return(flag);
|
|
}
|
|
|
|
#define TOSTR(A) " " + #A + " = " + (string)Tick.A
|
|
#define TOSTR2(A) " " + #A + " = " + ::DoubleToString(Tick.A, _Digits)
|
|
|
|
static string TickToString( const MqlTick &Tick )
|
|
{
|
|
// Нет проверки, что Tick.time == Tick.time_msc / 1000
|
|
return(TOSTR(time) + "." + ::IntegerToString(Tick.time_msc % 1000, 3, '0') +
|
|
TOSTR2(bid) + TOSTR2(ask) + TOSTR2(last)+ TOSTR(volume) + ORDERS::GetTickFlag(Tick.flags));
|
|
}
|
|
|
|
#undef TOSTR2
|
|
#undef TOSTR
|
|
|
|
bool IsChange( void )
|
|
{
|
|
_VC
|
|
bool Res = false;
|
|
double Profit = 0;
|
|
int j = 0;
|
|
|
|
for (int i = 0; i < this.AmountOrders; i++)
|
|
// this.Orders[i].IsChange2(Res, this, i, j, Profit) ;
|
|
{
|
|
Res |= this.Orders[i].IsChange(this.CurrentTick) && !this.Orders[i].IsClosed();
|
|
|
|
// if (this.Orders[i].IsClosed())
|
|
if (this.Orders[i].Ticket <= 0)
|
|
{
|
|
// https://www.mql5.com/ru/forum/282062/page70#comment_56002732
|
|
#ifdef ORDER_COMMISSION
|
|
this.Balance += this.Orders[i].GetProfit() + this.Orders[i].GetCommission();
|
|
#else // ORDER_COMMISSION
|
|
this.Balance += this.Orders[i].GetProfit();
|
|
#endif // ORDER_COMMISSION
|
|
|
|
this.AddHistoryOrder(this.Orders[i]);
|
|
|
|
#ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
if (this.SelectIndex == i)
|
|
this.Orders[this.SelectIndex = MAX_ORDERS - 1] = this.HistoryOrders[this.AmountHistoryOrders - 1];
|
|
else if (this.SelectIndex > i)
|
|
this.SelectIndex--;
|
|
#endif // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
}
|
|
else
|
|
{
|
|
#ifdef ORDER_COMMISSION
|
|
Profit += this.Orders[i].GetFullProfit();
|
|
#else // ORDER_COMMISSION
|
|
Profit += this.Orders[i].GetProfit();
|
|
#endif // ORDER_COMMISSION
|
|
|
|
if (i != j)
|
|
this.Orders[j] = this.Orders[i];
|
|
|
|
j++;
|
|
}
|
|
}
|
|
|
|
this.AmountOrders = j;
|
|
|
|
// https://www.mql5.com/ru/forum/282062/page70#comment_56002732
|
|
this.Equity = this.Balance + Profit;
|
|
|
|
this.FlagChange |= Res;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
return(Res);
|
|
}
|
|
|
|
void CloseBy( void )
|
|
{
|
|
int j = -1;
|
|
|
|
for (int i = 0; i < this.AmountOrders; i++)
|
|
if (!this.Orders[i].IsClosed() && this.Orders[i].IsPosition())
|
|
{
|
|
if (j < 0)
|
|
j = i;
|
|
else if (this.Orders[j].CloseBy(this.Orders[i], this.CurrentTick, this.Netting) && this.Orders[j].IsClosed())
|
|
{
|
|
i = j;
|
|
|
|
j = -1;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void Check( void )
|
|
{
|
|
_VC
|
|
while (this.IsChange())
|
|
if (this.Netting)
|
|
this.CloseBy();
|
|
|
|
return;
|
|
}
|
|
|
|
int GetIndex( const long &Ticket ) const
|
|
{
|
|
_VC
|
|
int Res = -1;
|
|
|
|
if ((this.SelectIndex < this.AmountOrders) && (this.Orders[this.SelectIndex].GetTicket() == Ticket))
|
|
Res = this.SelectIndex;
|
|
else
|
|
for (int i = 0; i < this.AmountOrders; i++)
|
|
if (this.Orders[i].GetTicket() == Ticket)
|
|
{
|
|
Res = i;
|
|
|
|
break;
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
// Нужно перебор менять на Generic-реализацию.
|
|
bool SelectByTicketHistory( const long &Ticket )
|
|
{
|
|
_VC
|
|
bool Res = false;
|
|
|
|
for (int i = 0; i < this.AmountHistoryOrders; i++)
|
|
// for (int i = this.AmountHistoryOrders - 1; i >= 0; i--) // Чаще ищутся позиции, что закрылись недавно.
|
|
if (this.HistoryOrders[i].GetTicket() == Ticket)
|
|
{
|
|
VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex = MAX_ORDERS - 1]) = this.HistoryOrders[i];
|
|
Res = true;
|
|
|
|
break;
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool SelectByTicket( const long &Ticket, const int Pool )
|
|
{
|
|
_VC
|
|
return((VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder.GetCloseTimeMsc() && this.SelectOrder,
|
|
this.Orders[this.SelectIndex]).GetTicket() == Ticket) ||
|
|
((Pool == MODE_TRADES) ? this.SelectByTicketTrades(Ticket) || this.SelectByTicketHistory(Ticket)
|
|
: this.SelectByTicketHistory(Ticket) || this.SelectByTicketTrades(Ticket)));
|
|
}
|
|
|
|
bool SelectByPosHistory( const int Index )
|
|
{
|
|
_VC
|
|
const bool Res = (Index >= 0) && (Index < this.AmountHistoryOrders);
|
|
|
|
if (Res)
|
|
VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex = MAX_ORDERS - 1]) = this.HistoryOrders[Index];
|
|
|
|
return(Res);
|
|
}
|
|
|
|
void Recalculate( void )
|
|
{
|
|
this.Balance = 0;
|
|
|
|
for (int i = this.AmountHistoryOrders - 1; i >= 0; i--)
|
|
this.Balance += this.HistoryOrders[i].GetFullProfit();
|
|
|
|
this.Equity = this.Balance;
|
|
|
|
for (int i = this.AmountOrders - 1; i >= 0; i--)
|
|
this.Equity += this.Orders[i].GetFullProfit();
|
|
|
|
this.ReserveHistoryOrders = this.AmountHistoryOrders;
|
|
|
|
this.InitStat();
|
|
|
|
#ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.Orders[this.SelectIndex = MAX_ORDERS - 1].SetTicket(0);
|
|
#else // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.SelectIndex = 0;
|
|
this.SelectOrder.SetTicket(0);
|
|
#endif // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY #else
|
|
|
|
ORDER::SetTicketCount((int)this.GetMaxTicket());
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = false;
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
return;
|
|
}
|
|
|
|
double GetMargin() const
|
|
{
|
|
double result = 0;
|
|
for (int i = 0; i < this.AmountOrders; i++)
|
|
{
|
|
if (!this.Orders[i].IsClosed() && this.Orders[i].IsPosition())
|
|
{
|
|
result += this.Orders[i].GetMargin();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
TICKET_TYPE GetMaxTicket( void ) const
|
|
{
|
|
TICKET_TYPE MaxTicket = this.GetMaxHistoryTicket();
|
|
|
|
for (int i = AmountOrders - 1; i >= 0; i--)
|
|
{
|
|
const TICKET_TYPE Ticket = this.Orders[i].GetTicket();
|
|
|
|
if (Ticket > MaxTicket)
|
|
MaxTicket = Ticket;
|
|
}
|
|
|
|
return(MaxTicket);
|
|
}
|
|
|
|
protected:
|
|
#ifdef __MQL5__
|
|
bool Swap( ORDERS &OtherOrders )
|
|
{
|
|
const bool Res = this.HISTORYORDERS::Swap(OtherOrders);
|
|
|
|
if (Res)
|
|
{
|
|
::ArrayCopy(this.Orders, OtherOrders.Orders, 0, 0, OtherOrders.AmountOrders);
|
|
|
|
#ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
if (OtherOrders.SelectIndex == MAX_ORDERS - 1)
|
|
this.Orders[MAX_ORDERS - 1] = OtherOrders.Orders[MAX_ORDERS - 1];
|
|
#endif // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
|
|
this.Netting = OtherOrders.Netting;
|
|
|
|
this.SelectIndex = OtherOrders.SelectIndex;
|
|
|
|
this.PrevAmountOrders = OtherOrders.PrevAmountOrders;
|
|
|
|
this.ID = OtherOrders.ID;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallFunc = OtherOrders.CallFunc;
|
|
this.CallChange = OtherOrders.CallChange; // На текущем тике вызван this.IsChange().
|
|
|
|
this.PriceBorders = OtherOrders.PriceBorders;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.SelectTick = OtherOrders.SelectTick;
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
this.SymbolBase = OtherOrders.SymbolBase;
|
|
|
|
this.CurrentTick = OtherOrders.CurrentTick;
|
|
|
|
this.AmountOrders = OtherOrders.AmountOrders;
|
|
this.SymbolOrders = OtherOrders.SymbolOrders;
|
|
|
|
this.Handle = OtherOrders.Handle;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.SelectOrder = OtherOrders.SelectOrder;
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
|
|
this.Balance = OtherOrders.Balance;
|
|
this.Equity = OtherOrders.Equity;
|
|
|
|
// this.MyPointer = OtherOrders.MyPointer;
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
#endif // #ifdef __MQL5__
|
|
|
|
public: // ORDER::IsChange2
|
|
ORDERS* MyPointer;
|
|
|
|
ORDER Orders[MAX_ORDERS]; // sizeof(this.Orders) - только для статик.
|
|
protected:
|
|
|
|
SYMBOL_BASE SymbolBase;
|
|
|
|
public:
|
|
MqlTick CurrentTick;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
MqlTick SelectTick;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
int AmountOrders;
|
|
string SymbolOrders;
|
|
|
|
/*const */int Handle; // VIRTUAL_SELECTORDERS_OBJECT: ORDERS::Swap.
|
|
|
|
ORDER SelectOrder;
|
|
|
|
double Balance;
|
|
double Equity;
|
|
|
|
ORDERS( const int iHandle, const datetime StartTime = 0, const string sSymbol = NULL ) :
|
|
Handle(iHandle), SelectIndex(0), PrevAmountOrders(0), AmountOrders(0)
|
|
{
|
|
this.SymbolBase = sSymbol;
|
|
this.SymbolOrders = this.SymbolBase.GetSymbol();
|
|
|
|
this.MyPointer = this.Handle ? &this : NULL;
|
|
|
|
if (this.Handle < 0) // default SymbolID = 0.
|
|
this.SymbolBase.SymbolID = -this.Handle;
|
|
|
|
this.ID = NULL;
|
|
|
|
MqlTick Tick = {};
|
|
|
|
Tick.time_msc = (long)StartTime * 1000;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = false;
|
|
this.CallFunc = true;
|
|
|
|
this.SelectTick = Tick;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
this.NewTick(Tick);
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = true; // Для SNAPSHOT::SNAPSHOT.
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
}
|
|
|
|
ORDERS( const int iHandle, const datetime StartTime, const SYMBOL_BASE &sSymbol ) :
|
|
Handle(iHandle), SelectIndex(0), PrevAmountOrders(0), AmountOrders(0)
|
|
{
|
|
this.SymbolBase = sSymbol;
|
|
this.SymbolOrders = this.SymbolBase.GetSymbol();
|
|
|
|
if (this.Handle < 0) // default SymbolID = 0.
|
|
this.SymbolBase.SymbolID = -this.Handle;
|
|
|
|
this.ID = NULL;
|
|
|
|
MqlTick Tick = {};
|
|
|
|
Tick.time_msc = (long)StartTime * 1000;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = false;
|
|
this.CallFunc = true;
|
|
|
|
this.SelectTick = Tick;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
this.NewTick(Tick);
|
|
}
|
|
|
|
// DBL_MIN - тип Неттинга и размер баланса берутся с текущего счета.
|
|
void Set( const double dBalance = DBL_MIN, const bool bNetting = false )
|
|
{
|
|
this.Balance = 0;
|
|
this.Equity = 0;
|
|
this.Netting = (dBalance != DBL_MIN) ? bNetting :
|
|
#ifdef __MQL5__
|
|
!((ENUM_ACCOUNT_MARGIN_MODE)::AccountInfoInteger(ACCOUNT_MARGIN_MODE) == ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
|
|
#else // __MQL5__
|
|
bNetting
|
|
#endif //__MQL5__
|
|
;
|
|
|
|
this.AmountOrders = 0;
|
|
|
|
#ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.Orders[this.SelectIndex = MAX_ORDERS - 1].SetTicket(0);
|
|
#else // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.SelectIndex = 0;
|
|
this.SelectOrder.SetTicket(0); // Обходим отсутствие конструктора: ORDER_BASE::ORDER_BASE( void ) : Ticket(0).
|
|
#endif // #ifdef VIRTUAL_ORDERSELECT_WITHOUT_COPY #else
|
|
|
|
this.AmountHistoryOrders = 0;
|
|
this.ReserveHistoryOrders = 0; // ::ArrayResize(this.HistoryOrders, RESERVE_HISTORY_ORDERS);
|
|
|
|
if (dBalance > 0) // Не всегда создание виртуального окружения требует депозита (увеличения счетчика тикетов) - CopyTo, например.
|
|
this.OrderDeposit((dBalance != DBL_MIN) ? dBalance : ::AccountInfoDouble(ACCOUNT_BALANCE));
|
|
|
|
return;
|
|
}
|
|
|
|
bool CopyFrom( const ORDERS* SourceOrders )
|
|
{
|
|
bool Res = (::CheckPointer(SourceOrders) != POINTER_INVALID);
|
|
|
|
if (Res)
|
|
{
|
|
// this = SourceOrders; // https://www.mql5.com/ru/forum/1111/page2480#comment_12038312
|
|
|
|
this.Netting = SourceOrders.Netting;
|
|
this.Balance = SourceOrders.Balance;
|
|
this.Equity = SourceOrders.Equity;
|
|
|
|
this.AmountOrders = ::ArrayCopy(this.Orders, SourceOrders.Orders, 0, 0, SourceOrders.AmountOrders); // Гарантированное копирование - static[].
|
|
this.CurrentTick = SourceOrders.CurrentTick;
|
|
|
|
this.SelectIndex = SourceOrders.SelectIndex;
|
|
this.SelectOrder = SourceOrders.SelectOrder;
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.SelectTick = this.CurrentTick;
|
|
|
|
this.CallChange = false;
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
// https://www.mql5.com/ru/forum/331186/page12#comment_17360688
|
|
#ifdef __MQL5__
|
|
Res = this.HISTORYORDERS::CopyFrom(SourceOrders);
|
|
#else // __MQL5__
|
|
Res = this.CopyFrom((const HISTORYORDERS*)SourceOrders); // https://www.mql5.com/ru/forum/170953/page33#comment_19199513
|
|
#endif // __MQL5__
|
|
|
|
this.FlagChange |= Res;
|
|
|
|
ORDER::SetTicketCount((int)SourceOrders.GetMaxTicket());
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool CopyOrder( const bool WithoutHistory = false )
|
|
{
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex = MAX_ORDERS - 1]).Copy(WithoutHistory));
|
|
}
|
|
|
|
// Не желательно объединять клонированные (CopyFrom) виртуальные окружения, т.к. будет повторение тикетов.
|
|
// Для Single-варианта.
|
|
void operator +=( const ORDERS* SourceOrders )
|
|
{
|
|
if (::CheckPointer(SourceOrders) != POINTER_INVALID)
|
|
{
|
|
// SelectIndex и SelectOrder трогать не нужно.
|
|
|
|
this.Balance += SourceOrders.Balance;
|
|
this.Equity += SourceOrders.Equity;
|
|
|
|
if (SourceOrders.AmountOrders)// https://www.mql5.com/ru/forum/170952/page167#comment_15258160
|
|
this.AmountOrders += ::ArrayCopy(this.Orders, SourceOrders.Orders, this.AmountOrders, 0, SourceOrders.AmountOrders);
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = false;
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
ORDER_BASE NewHistoryOrders[];
|
|
|
|
const int Size = ::ArrayResize(NewHistoryOrders, this.AmountHistoryOrders + SourceOrders.AmountHistoryOrders);
|
|
|
|
for (int i = 0, j = 0, k = 0; k < Size; k++)
|
|
NewHistoryOrders[k] = (i < this.AmountHistoryOrders) ? (((j == SourceOrders.AmountHistoryOrders) ||
|
|
(this.HistoryOrders[i].GetCloseTimeMsc() < SourceOrders.HistoryOrders[j].GetCloseTimeMsc()))
|
|
? this.HistoryOrders[i++] : SourceOrders.HistoryOrders[j++])
|
|
: SourceOrders.HistoryOrders[j++];
|
|
|
|
#ifdef __MQL5__
|
|
::ArraySwap(this.HistoryOrders, NewHistoryOrders);
|
|
#else // __MQL5__
|
|
::ArrayCopy(this.HistoryOrders, NewHistoryOrders);
|
|
#endif // __MQL5__
|
|
|
|
this.AmountHistoryOrders = Size;
|
|
this.ReserveHistoryOrders = Size;
|
|
|
|
this.FlagChange = true;
|
|
|
|
ORDER::SetTicketCount((int)SourceOrders.GetMaxTicket());
|
|
|
|
this.InitStat();
|
|
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
bool IsNetting( void ) const
|
|
{
|
|
_VC
|
|
return(this.Netting);
|
|
}
|
|
|
|
void NewTick( const MqlTick &Tick ) // Нет проверки, что Tick.time == Tick.time_msc / 1000
|
|
{
|
|
_VC
|
|
this.CurrentTick = Tick;
|
|
|
|
#ifndef VIRTUAL_TESTER
|
|
#ifndef VIRTUAL_TESTER_MULTI
|
|
// https://www.mql5.com/ru/forum/282062/page56#comment_53793273
|
|
this.CurrentTick.flags |= this.Handle << 16; // Метка виртуального тика.
|
|
#endif // #ifndef VIRTUAL_TESTER_MULTI
|
|
#endif // #ifndef VIRTUAL_TESTER
|
|
|
|
#ifdef TICKS_FORCE_NORMALIZE
|
|
this.CurrentTick.bid = ::NormalizeDouble(this.CurrentTick.bid, 8);
|
|
this.CurrentTick.ask = ::NormalizeDouble(this.CurrentTick.ask, 8);
|
|
#endif // TICKS_FORCE_NORMALIZE
|
|
|
|
#ifdef TICKS_CORRECT_TIME
|
|
if (!(this.CurrentTick.time_msc % 1000))
|
|
this.CurrentTick.time_msc++;
|
|
#endif // TICKS_CORRECT_TIME
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallChange = false;
|
|
|
|
if (this.CallFunc)
|
|
{
|
|
this.Check();
|
|
|
|
this.CallFunc = false;
|
|
this.PriceBorders.Ready = false;
|
|
}
|
|
else if (!this.PriceBorders.Ready)
|
|
{
|
|
this.PriceBorders.Set(this.Orders, this.AmountOrders);
|
|
|
|
if (this.AmountOrders && this.PriceBorders.IsAccept(this.CurrentTick))
|
|
// this.PriceBorders.Ready = !this.Check();
|
|
this.Check();
|
|
// else
|
|
// this.CallChange = false;
|
|
}
|
|
else if (this.AmountOrders && this.PriceBorders.IsAccept(this.CurrentTick))
|
|
// this.PriceBorders.Ready = !
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
this.Check();
|
|
|
|
return;
|
|
}
|
|
|
|
void NewTick( const MqlTick &Ticks[], const STRATEGY Strategy = NULL )
|
|
{
|
|
const int Size = ::ArraySize(Ticks);
|
|
|
|
if (Strategy != NULL)
|
|
for (int i = 0; (i < Size) && (!::IsStopped()); i++)
|
|
{
|
|
this.NewTick(Ticks[i]);
|
|
|
|
Strategy();
|
|
}
|
|
else
|
|
for (int i = 0; i < Size; i++)
|
|
this.NewTick(Ticks[i]);
|
|
|
|
return;
|
|
}
|
|
|
|
// Должна вызываться только так: VIRTUAL::SelectOrders.NewTickMulti(Ticks, StrategyMulti)
|
|
// Только для Single-окружения.
|
|
// Причина написания: https://www.mql5.com/ru/forum/462835/page24#comment_52772777
|
|
void NewTickMulti( const MqlTick &Ticks[], const STRATEGY_MULTI StrategyMulti = NULL )
|
|
{
|
|
if (this.IsSingle())
|
|
{
|
|
const int Size = ::ArraySize(Ticks);
|
|
|
|
if (StrategyMulti != NULL)
|
|
for (int i = 0; (i < Size) && (!::IsStopped()); i++)
|
|
{
|
|
this.NewTick(Ticks[i]);
|
|
|
|
StrategyMulti(this.SymbolOrders, this.SymbolBase.SymbolID); // Предполагается, что VIRTUAL::SelectOrders == &this.
|
|
}
|
|
else
|
|
for (int i = 0; i < Size; i++)
|
|
this.NewTick(Ticks[i]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
bool OrderDeposit( const double Deposit )
|
|
{
|
|
if (Deposit)
|
|
{
|
|
ORDER Order;
|
|
|
|
Order.Deposit(Deposit, this.CurrentTick);
|
|
|
|
this.AddHistoryOrder(Order);
|
|
|
|
this.Balance += Deposit;
|
|
this.Equity += Deposit;
|
|
}
|
|
|
|
return((bool)Deposit);
|
|
}
|
|
|
|
virtual TICKET_TYPE OrderSend( const string&, const int &Type, const double &dVolume, const double &Price,
|
|
const int &SlipPage, const double &SL, const double &TP,
|
|
const string &comment, const MAGIC_TYPE &magic, const datetime &dExpiration )
|
|
{
|
|
_VC
|
|
TICKET_TYPE Res = -1;
|
|
|
|
if (this.Orders[this.AmountOrders].Create(this.SymbolBase, (ENUM_ORDER_TYPE)Type, dVolume,
|
|
Price, SL, TP, magic, comment, this.CurrentTick))
|
|
{
|
|
Res = this.Orders[this.AmountOrders].GetTicket();
|
|
|
|
this.FlagChange = true; // https://www.mql5.com/ru/forum/282062/page72#comment_56065971
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
if (this.Orders[this.AmountOrders++].IsPosition())
|
|
{
|
|
if (this.Netting)
|
|
this.CloseBy();
|
|
|
|
this.IsChange();
|
|
}
|
|
else
|
|
this.Check();
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
virtual bool Stop( void )
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
for (int i = 0; i < this.AmountOrders; i++)
|
|
this.Orders[i].Stop(this.CurrentTick);
|
|
|
|
this.IsChange();
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
// Здесь можно ужать массив истории торгов для экономии памяти.
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool OrderSelect( const long Index, const int &Select, const int &Pool )
|
|
{
|
|
_VC
|
|
return((Select == SELECT_BY_POS) ?
|
|
((Pool == MODE_TRADES) ? this.SelectByPos((int)Index) : this.SelectByPosHistory((int)Index)) :
|
|
this.SelectByTicket(Index, Pool));
|
|
}
|
|
|
|
bool OrderSelect( const long Index, const int &Select )
|
|
{
|
|
_VC
|
|
return((Select == SELECT_BY_POS) ? this.SelectByPos((int)Index) : this.SelectByTicket(Index, MODE_TRADES));
|
|
}
|
|
|
|
virtual bool OrderClose( const long Ticket, const double &dLots, const double &Price )
|
|
{
|
|
_VC
|
|
bool Res = false;
|
|
const int Pos = this.GetIndex(Ticket);
|
|
|
|
if (Pos >= 0)
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
const double LeftLots = this.Orders[Pos].Close(dLots, this.CurrentTick);
|
|
|
|
Res = this.Orders[Pos].IsClosed();
|
|
|
|
if (Res)
|
|
{
|
|
if (LeftLots)
|
|
{
|
|
this.Orders[this.AmountOrders] = this.Orders[Pos];
|
|
|
|
this.Orders[this.AmountOrders++].SetLots(LeftLots);
|
|
}
|
|
|
|
this.IsChange();
|
|
}
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
virtual bool OrderModify( const long Ticket, const double &Price, const double &SL, const double &TP, const datetime &Expiration )
|
|
{
|
|
_VC
|
|
const int Pos = this.GetIndex(Ticket);
|
|
const bool Res = (Pos >= 0) ? this.Orders[Pos].Modify(Price, SL, TP, this.CurrentTick) : false;
|
|
|
|
if (Res)
|
|
{
|
|
this.FlagChange = true;
|
|
|
|
this.Check();
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
virtual bool OrderCloseBy( const long Ticket, const long Opposite )
|
|
{
|
|
bool Res = false;
|
|
const int Pos1 = (Ticket != Opposite) ? this.GetIndex(Ticket) : -1;
|
|
|
|
if (Pos1 >= 0)
|
|
{
|
|
const int Pos2 = this.GetIndex(Opposite);
|
|
|
|
if (Pos2 >= 0)
|
|
{
|
|
Res = this.Orders[Pos1].CloseBy(this.Orders[Pos2], this.CurrentTick);
|
|
|
|
if (Res)
|
|
{
|
|
this.IsChange();
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
}
|
|
}
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
virtual bool OrderDelete( const long Ticket )
|
|
{
|
|
_VC
|
|
bool Res = false;
|
|
const int Pos = this.GetIndex(Ticket);
|
|
|
|
if (Pos >= 0)
|
|
{
|
|
Res = this.Orders[Pos].Delete(this.CurrentTick);
|
|
|
|
if (Res)
|
|
{
|
|
this.IsChange();
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
}
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
int OrdersTotal2( void ) const // 2 - MT4Orders
|
|
{
|
|
return(this.AmountOrders);
|
|
}
|
|
|
|
int OrdersHistoryTotal( void ) const
|
|
{
|
|
return(this.AmountHistoryOrders);
|
|
}
|
|
|
|
#define ORDERFUNCTION(NAME,T) \
|
|
T Order##NAME( void ) const \
|
|
{ \
|
|
_VC return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, \
|
|
this.Orders[this.SelectIndex]).Get##NAME()); \
|
|
}
|
|
|
|
ORDERFUNCTION(Ticket, TICKET_TYPE)
|
|
ORDERFUNCTION(Type, int)
|
|
ORDERFUNCTION(Lots, double)
|
|
ORDERFUNCTION(OpenPrice, double)
|
|
ORDERFUNCTION(OpenTimeMsc, long)
|
|
ORDERFUNCTION(OpenTime, datetime)
|
|
ORDERFUNCTION(StopLoss, double)
|
|
ORDERFUNCTION(TakeProfit, double)
|
|
ORDERFUNCTION(CloseTimeMsc, long)
|
|
ORDERFUNCTION(CloseTime, datetime)
|
|
ORDERFUNCTION(Expiration, datetime)
|
|
ORDERFUNCTION(MagicNumber, MAGIC_TYPE)
|
|
ORDERFUNCTION(Commission, double)
|
|
ORDERFUNCTION(Swap, double)
|
|
ORDERFUNCTION(SymbolID, int)
|
|
// ORDERFUNCTION(Symbol, string)
|
|
ORDERFUNCTION(Comment, string)
|
|
ORDERFUNCTION(OpenPriceRequest, double)
|
|
ORDERFUNCTION(ClosePriceRequest, double)
|
|
ORDERFUNCTION(OpenReason, ENUM_DEAL_REASON)
|
|
ORDERFUNCTION(CloseReason, ENUM_DEAL_REASON)
|
|
|
|
#undef ORDERFUNCTION
|
|
|
|
double OrderProfit( void )
|
|
{
|
|
_VC
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).CloseTimeMsc)
|
|
{
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
// this.CallFunc = true;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
if (this.SelectTick.time)
|
|
{
|
|
this.SelectOrder.IsChange(this.SelectTick);
|
|
this.SelectTick.time = 0;
|
|
}
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
}
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetProfit());
|
|
}
|
|
|
|
double OrderClosePrice( void )
|
|
{
|
|
_VC
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).CloseTimeMsc)
|
|
{
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
// this.CallFunc = true;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
if (this.SelectTick.time)
|
|
{
|
|
this.SelectOrder.IsChange(this.SelectTick);
|
|
this.SelectTick.time = 0;
|
|
}
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
}
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetClosePrice());
|
|
}
|
|
|
|
virtual string OrderSymbol( void ) const
|
|
{
|
|
_VC return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetCloseTimeMsc()
|
|
? VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetSymbol()
|
|
: this.SymbolOrders);
|
|
}
|
|
|
|
TICKET_TYPE OrderTicketOpen( void ) const
|
|
{
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetTicket());
|
|
}
|
|
|
|
TICKET_TYPE OrderTicketID( void ) const
|
|
{
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetTicket());
|
|
}
|
|
|
|
int OrderDealsAmount( void ) const
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
double OrderLotsOpen( void ) const
|
|
{
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetLots());
|
|
}
|
|
|
|
void OrderPrint( void )
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).CloseTimeMsc)
|
|
{
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
// this.CallFunc = true;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
if (this.SelectTick.time)
|
|
{
|
|
this.SelectOrder.IsChange(this.SelectTick);
|
|
this.SelectTick.time = 0;
|
|
}
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
}
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetPrint(this.CurrentTick.time);
|
|
|
|
return;
|
|
}
|
|
|
|
bool OrderComment( const string &NewComment )
|
|
{
|
|
_VC
|
|
const long Ticket = VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]).GetTicket();
|
|
const int Index = this.GetIndex(Ticket);
|
|
const bool Res = (Index >= 0);
|
|
|
|
if (Res)
|
|
this.Orders[this.SelectIndex].SetComment(NewComment);
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool TesterDeposit( const double Deposit )
|
|
{
|
|
return(this.OrderDeposit(Deposit));
|
|
}
|
|
|
|
bool TesterWithdrawal( const double Withdraw )
|
|
{
|
|
return(this.TesterDeposit(-Withdraw));
|
|
}
|
|
|
|
virtual double AccountBalance( void ) const
|
|
{
|
|
return(::NormalizeDouble(this.Balance, SYMBOL_BASE::DigitsCurrency));
|
|
}
|
|
|
|
virtual double AccountEquity( void )
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
// this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
return(::NormalizeDouble(this.Equity, SYMBOL_BASE::DigitsCurrency));
|
|
}
|
|
|
|
virtual double AccountProfit( void )
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
// this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
return(::NormalizeDouble(this.Equity - this.Balance, SYMBOL_BASE::DigitsCurrency));
|
|
}
|
|
|
|
datetime TimeCurrent( void ) const
|
|
{
|
|
return(this.CurrentTick.time);
|
|
}
|
|
|
|
datetime TimeCurrent( MqlDateTime &StructTime ) const
|
|
{
|
|
::TimeToStruct(this.CurrentTick.time, StructTime);
|
|
|
|
return(this.CurrentTick.time);
|
|
}
|
|
|
|
datetime TimeTradeServer( void ) const
|
|
{
|
|
return(this.CurrentTick.time);
|
|
}
|
|
|
|
datetime TimeTradeServer( MqlDateTime &StructTime ) const
|
|
{
|
|
::TimeToStruct(this.CurrentTick.time, StructTime);
|
|
|
|
return(this.CurrentTick.time);
|
|
}
|
|
|
|
virtual bool SymbolInfoTick( const string &Symb, MqlTick &Tick )
|
|
{
|
|
_VC
|
|
Tick = this.CurrentTick;
|
|
|
|
return(true);
|
|
}
|
|
|
|
// Где-то логично этому находиться в SYMBOL_BASE.
|
|
virtual double SymbolInfoDouble( const string &Symb, const ENUM_SYMBOL_INFO_DOUBLE Property )
|
|
{
|
|
_VC
|
|
|
|
// Если OrderSymbol() != SymbolBase (в Virtual-историю можно писать любые символы), то будут неправильные данные.
|
|
switch (Property)
|
|
{
|
|
case SYMBOL_BID:
|
|
return(this.CurrentTick.bid);
|
|
case SYMBOL_ASK:
|
|
return(this.CurrentTick.ask);
|
|
case SYMBOL_POINT:
|
|
return(this.SymbolBase.Point);
|
|
case SYMBOL_TRADE_TICK_VALUE:
|
|
case SYMBOL_TRADE_TICK_VALUE_LOSS:
|
|
case SYMBOL_TRADE_TICK_VALUE_PROFIT:
|
|
return(this.SymbolBase.TickValue * this.SymbolBase.TickSize);
|
|
case SYMBOL_TRADE_TICK_SIZE:
|
|
return(this.SymbolBase.TickSize);
|
|
}
|
|
|
|
return(::SymbolInfoDouble(Symb, Property));
|
|
/*
|
|
return((Property == SYMBOL_BID) ? this.CurrentTick.bid
|
|
: ((Property == SYMBOL_ASK) ? this.CurrentTick.ask : ::SymbolInfoDouble(Symb, Property)));
|
|
*/
|
|
}
|
|
|
|
virtual bool SymbolInfoDouble( const string &Symb, const ENUM_SYMBOL_INFO_DOUBLE Property, double &Value )
|
|
{
|
|
_VC
|
|
|
|
switch (Property)
|
|
{
|
|
case SYMBOL_BID:
|
|
case SYMBOL_ASK:
|
|
case SYMBOL_POINT:
|
|
case SYMBOL_TRADE_TICK_VALUE:
|
|
case SYMBOL_TRADE_TICK_VALUE_LOSS:
|
|
case SYMBOL_TRADE_TICK_VALUE_PROFIT:
|
|
case SYMBOL_TRADE_TICK_SIZE:
|
|
Value = ORDERS::SymbolInfoDouble(Symb, Property); // https://www.mql5.com/ru/forum/478178/page23#comment_56068453
|
|
|
|
return(true);
|
|
}
|
|
|
|
return(::SymbolInfoDouble(Symb, Property, Value));
|
|
|
|
/*
|
|
const bool Res = (Property == SYMBOL_BID) || (Property == SYMBOL_ASK);
|
|
|
|
if (Res)
|
|
{
|
|
if (Property == SYMBOL_BID)
|
|
Value = this.CurrentTick.bid;
|
|
else
|
|
Value = this.CurrentTick.ask;
|
|
}
|
|
|
|
return(Res ? true : ::SymbolInfoDouble(Symb, Property, Value));
|
|
*/
|
|
}
|
|
|
|
virtual long SymbolInfoInteger( const string &Symb, const ENUM_SYMBOL_INFO_INTEGER Property )
|
|
{
|
|
_VC
|
|
|
|
// Если OrderSymbol() != SymbolBase (в Virtual-историю можно писать любые символы), то будут неправильные данные.
|
|
switch (Property)
|
|
{
|
|
case SYMBOL_TIME:
|
|
return(this.CurrentTick.time);
|
|
case SYMBOL_TIME_MSC:
|
|
return(this.CurrentTick.time_msc);
|
|
case SYMBOL_DIGITS:
|
|
return(this.SymbolBase.Digits);
|
|
case SYMBOL_SPREAD:
|
|
return((long)((this.CurrentTick.ask - this.CurrentTick.bid) / this.SymbolBase.Point + 0.1));
|
|
case SYMBOL_TRADE_MODE:
|
|
return(SYMBOL_TRADE_MODE_FULL);
|
|
}
|
|
|
|
return(::SymbolInfoInteger(Symb, Property));
|
|
|
|
/*
|
|
return((Property == SYMBOL_TIME) ? this.CurrentTick.time
|
|
: ((Property == SYMBOL_SPREAD) ? (long)((this.CurrentTick.ask - this.CurrentTick.bid) / this.SymbolBase.Point + 0.1) : ::SymbolInfoInteger(Symb, Property)));
|
|
*/
|
|
}
|
|
|
|
virtual bool SymbolInfoInteger( const string &Symb, const ENUM_SYMBOL_INFO_INTEGER Property, long &Value )
|
|
{
|
|
_VC
|
|
|
|
switch (Property)
|
|
{
|
|
case SYMBOL_TIME:
|
|
case SYMBOL_TIME_MSC:
|
|
case SYMBOL_DIGITS:
|
|
case SYMBOL_SPREAD:
|
|
case SYMBOL_TRADE_MODE:
|
|
Value = ORDERS::SymbolInfoInteger(Symb, Property); // https://www.mql5.com/ru/forum/478178/page23#comment_56068453
|
|
|
|
return(true);
|
|
}
|
|
|
|
return(::SymbolInfoInteger(Symb, Property, Value));
|
|
|
|
/*
|
|
const bool Res = (Property == SYMBOL_TIME) || (Property == SYMBOL_SPREAD);
|
|
|
|
if (Res)
|
|
{
|
|
if (Property == SYMBOL_TIME) // SYMBOL_TIME_MSC специально берется с реального окружения - нужно для ByPass.mqh.
|
|
Value = this.CurrentTick.time;
|
|
else
|
|
Value = (long)((this.CurrentTick.ask - this.CurrentTick.bid) / this.SymbolBase.Point + 0.1);
|
|
}
|
|
|
|
return(Res ? true : ::SymbolInfoInteger(Symb, Property, Value));
|
|
*/
|
|
}
|
|
|
|
long AccountInfoInteger( const ENUM_ACCOUNT_INFO_INTEGER Property ) const
|
|
{
|
|
#ifdef __MQL5__
|
|
return((Property == ACCOUNT_MARGIN_MODE) ? (this.Netting ? ACCOUNT_MARGIN_MODE_RETAIL_NETTING : ACCOUNT_MARGIN_MODE_RETAIL_HEDGING) : ::AccountInfoInteger(Property));
|
|
#else // __MQL5__
|
|
return(::AccountInfoInteger(Property));
|
|
#endif // __MQL5__
|
|
}
|
|
|
|
double AccountInfoDouble( const ENUM_ACCOUNT_INFO_DOUBLE Property )
|
|
{
|
|
double Res;
|
|
|
|
switch (Property)
|
|
{
|
|
case ACCOUNT_BALANCE:
|
|
Res = this.AccountBalance();
|
|
|
|
break;
|
|
case ACCOUNT_PROFIT:
|
|
Res = this.AccountProfit();
|
|
|
|
break;
|
|
case ACCOUNT_EQUITY:
|
|
Res = this.AccountEquity();
|
|
|
|
break;
|
|
case ACCOUNT_MARGIN:
|
|
Res = this.GetMargin();
|
|
|
|
break;
|
|
case ACCOUNT_MARGIN_FREE:
|
|
Res = this.AccountEquity() - this.GetMargin();
|
|
|
|
break;
|
|
default:
|
|
Res = ::AccountInfoDouble(Property);
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
string ToString( int LastHistoryOrders = 0, const bool Pending = true )
|
|
{
|
|
string Str = ORDERS::TickToString(this.CurrentTick) + "\n\n";
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
for (int i = 0; i < this.AmountOrders; i++)
|
|
Str += this.Orders[i].ToString(this.CurrentTick.time) + "\n";
|
|
|
|
Str += (this.AmountOrders ? "\n" : NULL) + "Balance = " + ::DoubleToString(this.Balance, 2) +
|
|
", Equity = " + ::DoubleToString(this.Equity, 2) +
|
|
(this.AmountHistoryOrders && (this.HistoryOrders[0].GetType() == OP_BALANCE)
|
|
? ", Profit = " + ::DoubleToString(this.Equity - this.HistoryOrders[0].GetProfit(), 2) : NULL) +
|
|
(this.AmountHistoryOrders ? ", " + ::TimeToString(this.HistoryOrders[0].GetOpenTime(), TIME_DATE) + " - " + (string)this.TimeCurrent() : NULL);
|
|
|
|
if (LastHistoryOrders > 0)
|
|
for (int i = this.AmountHistoryOrders - 1; (i >= 0) && LastHistoryOrders; i--)
|
|
if (Pending || (this.HistoryOrders[i].GetType() <= OP_SELL) || (this.HistoryOrders[i].GetType() == OP_BALANCE))
|
|
{
|
|
Str += "\n" + this.HistoryOrders[i].ToString(this.CurrentTick.time);
|
|
|
|
LastHistoryOrders--;
|
|
}
|
|
|
|
return(Str);
|
|
}
|
|
|
|
int GetMemoryUsed( void ) const
|
|
{
|
|
return(sizeof(this) + ::ArraySize(this.HistoryOrders) * sizeof(ORDER_BASE) + sizeof(this.Orders)); // sizeof(this.Orders) - только для статик.
|
|
}
|
|
|
|
const ORDER_BASE GetOrder( void ) const
|
|
{
|
|
return(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex]));
|
|
}
|
|
|
|
bool AddOrder( const ORDER_BASE &Order )
|
|
{
|
|
if (Order.GetCloseTime())
|
|
{
|
|
this.AddHistoryOrder(Order);
|
|
|
|
this.Balance += Order.GetProfit();
|
|
this.Equity += Order.GetProfit();
|
|
}
|
|
else
|
|
{
|
|
this.Orders[this.AmountOrders] = Order;
|
|
|
|
if (this.Orders[this.AmountOrders++].IsPosition())
|
|
{
|
|
if (this.Netting)
|
|
this.CloseBy();
|
|
|
|
this.IsChange();
|
|
}
|
|
else
|
|
this.Check();
|
|
}
|
|
|
|
ORDER::SetTicketCount((int)Order.GetTicket());
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool CalcSwaps( const double &SwapShort, const double &SwapLong, const datetime &RolloverTime, const int &Rollover3Days )
|
|
{
|
|
const double ChangeSwaps = HISTORYORDERS::CalcSwaps(SwapShort, SwapLong, RolloverTime, Rollover3Days);
|
|
|
|
this.Balance += ChangeSwaps;
|
|
this.Equity += ChangeSwaps;
|
|
|
|
this.FlagChange |= (bool)ChangeSwaps;
|
|
|
|
return(true);
|
|
}
|
|
|
|
#ifndef __MQL5__
|
|
// sizeof(MqlTick) в MT4/5 отличается
|
|
struct MqlTickMT5 : public MqlTick
|
|
{
|
|
double volume_real; // https://www.mql5.com/ru/forum/373986/page7#comment_24982259
|
|
};
|
|
#endif // #ifndef __MQL5__
|
|
|
|
uint Save ( const int FileHandle )
|
|
{
|
|
uint Res = 0;
|
|
|
|
if (FileHandle != INVALID_HANDLE)
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
Res += ::FileWriteInteger(FileHandle, this.AmountOrders * sizeof(ORDER));
|
|
|
|
if (this.AmountOrders)
|
|
Res += ::FileWriteArray(FileHandle, this.Orders, 0, this.AmountOrders) * sizeof(ORDER);
|
|
|
|
Res += ::FileWriteInteger(FileHandle, this.AmountHistoryOrders * sizeof(ORDER_BASE));
|
|
|
|
if (this.AmountHistoryOrders)
|
|
Res += ::FileWriteArray(FileHandle, this.HistoryOrders, 0, this.AmountHistoryOrders) * sizeof(ORDER_BASE);
|
|
|
|
Res += ::FileWriteInteger(FileHandle, sizeof(this.Netting));
|
|
Res += ::FileWriteInteger(FileHandle, this.Netting, sizeof(this.Netting));
|
|
|
|
#ifdef __MQL5__
|
|
Res += ::FileWriteInteger(FileHandle, sizeof(this.CurrentTick));
|
|
Res += ::FileWriteStruct(FileHandle, this.CurrentTick);
|
|
#else // #ifdef __MQL5__
|
|
MqlTickMT5 CurrentTickTmp = {};
|
|
CurrentTickTmp = this.CurrentTick;
|
|
|
|
Res += ::FileWriteInteger(FileHandle, sizeof(CurrentTickTmp));
|
|
Res += ::FileWriteStruct(FileHandle, CurrentTickTmp);
|
|
#endif // #ifdef __MQL5__ #else
|
|
|
|
uchar Bytes[];
|
|
|
|
Res += ::FileWriteInteger(FileHandle, ::StringToCharArray(this.ID, Bytes));
|
|
Res += ::FileWriteArray(FileHandle, Bytes);
|
|
|
|
Res += ::FileWriteInteger(FileHandle, sizeof(this.SymbolBase));
|
|
Res += ::FileWriteStruct(FileHandle, this.SymbolBase);
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
uint Save( const string FileName, const bool FileCommon = false )
|
|
{
|
|
uint Res = 0;
|
|
const int FileHandle = ::FileOpen(FileName, FILE_WRITE | FILE_BIN | (FileCommon ? FILE_COMMON : 0));
|
|
|
|
if (FileHandle != INVALID_HANDLE)
|
|
{
|
|
Res = this.Save(FileHandle);
|
|
|
|
::FileClose(FileHandle);
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool Load( const int FileHandle )
|
|
{
|
|
const bool Res = (FileHandle != INVALID_HANDLE);
|
|
|
|
if (Res)
|
|
{
|
|
if ((bool)(this.AmountOrders = ::FileReadInteger(FileHandle) / sizeof(ORDER)))
|
|
::FileReadArray(FileHandle, this.Orders, 0, this.AmountOrders);
|
|
|
|
if ((bool)(this.AmountHistoryOrders = ::FileReadInteger(FileHandle) / sizeof(ORDER_BASE)))
|
|
::FileReadArray(FileHandle, this.HistoryOrders, 0, this.AmountHistoryOrders);
|
|
|
|
::FileReadInteger(FileHandle);
|
|
this.Netting = ::FileReadInteger(FileHandle, sizeof(this.Netting));
|
|
|
|
::FileReadInteger(FileHandle);
|
|
#ifdef __MQL5__
|
|
::FileReadStruct(FileHandle, this.CurrentTick);
|
|
#else // #ifdef __MQL5__
|
|
MqlTickMT5 CurrentTickTmp;
|
|
|
|
::FileReadStruct(FileHandle, CurrentTickTmp);
|
|
this.CurrentTick = CurrentTickTmp;
|
|
#endif // #ifdef __MQL5__ #else
|
|
|
|
const int AmountBytes = ::FileReadInteger(FileHandle);
|
|
uchar Bytes[];
|
|
|
|
if (AmountBytes)
|
|
::FileReadArray(FileHandle, Bytes, 0, AmountBytes);
|
|
|
|
this.ID = AmountBytes ? ::CharArrayToString(Bytes) : NULL; // https://www.mql5.com/ru/forum/1111/page2323#comment_9414672
|
|
|
|
::FileReadInteger(FileHandle);
|
|
::FileReadStruct(FileHandle, this.SymbolBase);
|
|
|
|
this.SymbolOrders = this.SymbolBase.GetSymbol();
|
|
|
|
this.Recalculate();
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool Load( const string FileName, const bool FileCommon = false )
|
|
{
|
|
const int FileHandle = ::FileOpen(FileName, FILE_READ | FILE_BIN | (FileCommon ? FILE_COMMON : 0));
|
|
const bool Res = ORDERS::Load(FileHandle);
|
|
|
|
if (Res)
|
|
::FileClose(FileHandle);
|
|
|
|
return(Res);
|
|
}
|
|
#ifdef __TYPETOBYTES__
|
|
template <typename T>
|
|
uint Save( T &Array[], const int LastHistoryOrders = INT_MAX ) const
|
|
{
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (!this.CallChange)
|
|
this.IsChange();
|
|
|
|
this.CallFunc = true;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
::ArrayFree(Array);
|
|
|
|
CONTAINER<T> Container;
|
|
|
|
ORDER OrdersTmp[]; // Чтобы не записывать весь массив, а только полезный кусок
|
|
|
|
::ArrayCopy(OrdersTmp, this.Orders, 0, 0, this.AmountOrders);
|
|
Container[0] = OrdersTmp;
|
|
::ArrayFree(OrdersTmp);
|
|
|
|
ORDER_BASE HistoryOrdersTmp[]; // Чтобы не записывать весь массив, а только полезный кусок
|
|
|
|
if ((LastHistoryOrders >= 0) && (LastHistoryOrders < this.AmountHistoryOrders - 1) &&
|
|
::ArrayResize(HistoryOrdersTmp, LastHistoryOrders + 1) &&
|
|
this.GetReduceOrder(HistoryOrdersTmp[0], this.AmountHistoryOrders - LastHistoryOrders - 1))
|
|
::ArrayCopy(HistoryOrdersTmp, this.HistoryOrders, 1, this.AmountHistoryOrders - LastHistoryOrders, LastHistoryOrders);
|
|
else
|
|
::ArrayCopy(HistoryOrdersTmp, this.HistoryOrders, 0, 0, this.AmountHistoryOrders);
|
|
|
|
Container[1] = HistoryOrdersTmp;
|
|
::ArrayFree(HistoryOrdersTmp);
|
|
|
|
bool NettingTmp = this.Netting; // Метод обязан быть const, а переменная - не const. Чтобы добиться однозначной сигнатуры в CONTAINER.
|
|
Container[2] = NettingTmp;
|
|
|
|
#ifdef __MQL5__
|
|
MqlTick CurrentTickTmp = this.CurrentTick; // Метод обязан быть const, а переменная - не const. Чтобы добиться однозначной сигнатуры в CONTAINER.
|
|
#else // #ifdef __MQL5__
|
|
MqlTickMT5 CurrentTickTmp = this.CurrentTick;
|
|
#endif // #ifdef __MQL5__ #else
|
|
|
|
Container[3] = CurrentTickTmp;
|
|
|
|
Container[4] = this.ID; // Метод обязан быть const, а переменная - не const. Чтобы добиться однозначной сигнатуры в CONTAINER.
|
|
Container[5] = this.SymbolBase; // Метод обязан быть const, а переменная - не const. Чтобы добиться однозначной сигнатуры в CONTAINER.
|
|
|
|
#ifdef __MQL5__
|
|
return(::ArraySwap(Array, Container.Data) ? ::ArraySize(Array) : 0);
|
|
#else // #ifdef __MQL5__
|
|
return(::ArrayCopy(Array, Container.Data));
|
|
#endif // #ifdef __MQL5__ #else
|
|
}
|
|
|
|
template <typename T>
|
|
bool Load( const T &Array[] )
|
|
{
|
|
CONTAINER<T> Container;
|
|
|
|
const bool Res = (::ArrayCopy(Container.Data, Array) > 0);
|
|
|
|
if (Res)
|
|
{
|
|
ORDER OrdersTmp[];
|
|
|
|
this.AmountOrders = Container[0].Get(OrdersTmp); // Статический this.Orders будет возвращать неправильный this.AmountOrders.
|
|
::ArrayCopy(this.Orders, OrdersTmp);
|
|
::ArrayFree(OrdersTmp);
|
|
|
|
::ArrayFree(this.HistoryOrders);
|
|
this.AmountHistoryOrders = Container[1].Get(this.HistoryOrders);
|
|
|
|
Container[2].Get(this.Netting);
|
|
|
|
#ifdef __MQL5__
|
|
Container[3].Get(this.CurrentTick);
|
|
#else // #ifdef __MQL5__
|
|
this.CurrentTick = Container[3].Get<MqlTickMT5>();
|
|
#endif // #ifdef __MQL5__ #else
|
|
|
|
this.ID = Container[4].Get<string>();
|
|
|
|
this.SymbolBase = Container[5].Get<SYMBOL_BASE>();
|
|
this.SymbolOrders = this.SymbolBase.GetSymbol();
|
|
|
|
this.Recalculate();
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
#endif // #ifdef __TYPETOBYTES__
|
|
|
|
bool SetID( const string NewID )
|
|
{
|
|
this.ID = NewID;
|
|
|
|
return(true);
|
|
}
|
|
|
|
string GetID( void ) const
|
|
{
|
|
return(this.ID);
|
|
}
|
|
|
|
bool ReduceHistory( const int LastHistoryOrders, const bool ChangeHistory = false )
|
|
{
|
|
return(this.GetReduceOrder(VIRTUAL_ORDERSELECT_MACROS(this.SelectOrder, this.Orders[this.SelectIndex = MAX_ORDERS - 1]),
|
|
this.AmountHistoryOrders - LastHistoryOrders - 1, ChangeHistory));
|
|
}
|
|
|
|
virtual void MultiTick( const MqlTick &Ticks[] )
|
|
{
|
|
this.NewTick(Ticks[0]);
|
|
|
|
return;
|
|
}
|
|
|
|
virtual void MultiTick( void )
|
|
{
|
|
// static MqlTick Tick = {}; // https://www.mql5.com/ru/forum/170952/page250#comment_52908635
|
|
MqlTick Tick;
|
|
|
|
if (::SymbolInfoTick(this.SymbolOrders, Tick))
|
|
this.NewTick(Tick);
|
|
|
|
return;
|
|
}
|
|
|
|
virtual void MultiTick( const uint &Index, const MqlTick &Tick )
|
|
{
|
|
if (!Index)
|
|
this.NewTick(Tick);
|
|
|
|
return;
|
|
}
|
|
|
|
virtual void MultiTick( const uint &Index )
|
|
{
|
|
if (!Index)
|
|
this.MultiTick();
|
|
|
|
return;
|
|
}
|
|
|
|
// https://www.mql5.com/ru/forum/455977/page29#comment_51010450
|
|
bool IsAmountChanged( void )
|
|
{
|
|
const bool Res = (this.AmountOrders != this.PrevAmountOrders);
|
|
|
|
if (Res)
|
|
this.PrevAmountOrders = this.AmountOrders;
|
|
|
|
return(Res);
|
|
}
|
|
|
|
// https://www.mql5.com/ru/forum/455977/page29#comment_51010450
|
|
bool TickCalc( const MqlTick &Tick, ORDERS &objOrders )
|
|
{
|
|
this.NewTick(Tick);
|
|
|
|
if (this.AmountHistoryOrders)
|
|
this.MoveHistory(objOrders);
|
|
|
|
return(this.IsAmountChanged());
|
|
}
|
|
|
|
// https://www.mql5.com/ru/forum/455977/page29#comment_51010450
|
|
bool TickCalc( ORDERS &objOrders )
|
|
{
|
|
// static MqlTick Tick; // https://www.mql5.com/ru/forum/170952/page250#comment_52908635
|
|
MqlTick Tick;
|
|
|
|
return(::SymbolInfoTick(this.SymbolOrders, Tick) && this.TickCalc(Tick, objOrders));
|
|
}
|
|
|
|
// https://www.mql5.com/ru/forum/455977/page29#comment_51010450
|
|
virtual bool SelectByPos( const int Index )
|
|
{
|
|
_VC
|
|
const bool Res = (Index >= 0) && (Index < this.AmountOrders);
|
|
|
|
if (Res)
|
|
{
|
|
this.SelectIndex = Index;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.SelectOrder = this.Orders[this.SelectIndex];
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (this.CallChange)
|
|
this.SelectTick.time = 0;
|
|
else
|
|
this.SelectTick = this.CurrentTick;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
virtual bool SelectByTicketTrades( const long &Ticket )
|
|
{
|
|
_VC
|
|
const int Index = this.GetIndex(Ticket);
|
|
const bool Res = (Index >= 0);
|
|
|
|
if (Res)
|
|
{
|
|
this.SelectIndex = Index;
|
|
|
|
#ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
this.SelectOrder = this.Orders[this.SelectIndex];
|
|
|
|
#ifdef VIRTUAL_ALTERNATIVE
|
|
if (this.CallChange)
|
|
this.SelectTick.time = 0;
|
|
else
|
|
this.SelectTick = this.CurrentTick;
|
|
#endif // #ifdef VIRTUAL_ALTERNATIVE
|
|
|
|
#endif // #ifndef VIRTUAL_ORDERSELECT_WITHOUT_COPY
|
|
}
|
|
|
|
return(Res);
|
|
}
|
|
|
|
bool IsSingle( void ) const
|
|
{
|
|
return(this.GetAmountSymbols() == 1);
|
|
}
|
|
|
|
virtual int GetAmountSymbols( void ) const
|
|
{
|
|
return(1);
|
|
}
|
|
|
|
virtual int GetSymbols( string &Symbols[] ) const
|
|
{
|
|
const int Res = ::ArrayResize(Symbols, 1);
|
|
|
|
Symbols[0] = this.SymbolOrders;
|
|
|
|
return(Res);
|
|
}
|
|
|
|
virtual string GetSymbolByIndex( const int &Index ) const
|
|
{
|
|
return(!Index ? this.SymbolOrders : NULL);
|
|
}
|
|
|
|
virtual ORDERS* GetSubOrders( const int &Index )
|
|
{
|
|
return(!Index ? &this : NULL);
|
|
}
|
|
|
|
void ToNull( void )
|
|
{
|
|
this.Handle = 0;
|
|
this.MyPointer = NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
void operator =( ORDERS* OtherOrders )
|
|
{
|
|
if ((OtherOrders != this.MyPointer) && (OtherOrders != &this))
|
|
{
|
|
if (this.Handle)
|
|
this.MyPointer.Swap(this);
|
|
|
|
if (OtherOrders == NULL)
|
|
this.ToNull();
|
|
#ifdef __MQL5__
|
|
else
|
|
this.Swap(this.MyPointer = OtherOrders);
|
|
#endif // #ifdef __MQL5__
|
|
}
|
|
|
|
return;
|
|
}
|
|
};
|
|
|
|
#undef VIRTUAL_ORDERSELECT_MACROS |