forked from antekov/Adwizard
//+------------------------------------------------------------------+
| |
//| VirtualOrder.mqh |
| |
//| Copyright 2019-2025, Yuriy Bykov |
| |
//| https://www.mql5.com/ru/users/antekov |
| |
//+------------------------------------------------------------------+
| |
#property copyright "Copyright 2019-2025, Yuriy Bykov"
| |
#property link "https://www.mql5.com/ru/users/antekov"
| |
#property version "1.09"
| |
| |
#include <Trade\SymbolInfo.mqh>
| |
| |
//+------------------------------------------------------------------+
| |
//| Предварительные определения классов |
| |
//+------------------------------------------------------------------+
| |
class CVirtualOrder;
| |
class CVirtualReceiver;
| |
class CVirtualStrategy;
| |
| |
#include "../Utils/SymbolsMonitor.mqh"
| |
#include "VirtualReceiver.mqh"
| |
#include "VirtualStrategy.mqh"
| |
| |
// Структура для чтения/записи из БД
| |
// основных свойств виртуального ордера/позиции
| |
struct VirtualOrderStruct {
| |
string strategyHash;
| |
int strategyIndex;
| |
ulong ticket;
| |
string symbol;
| |
double lot;
| |
ENUM_ORDER_TYPE type;
| |
datetime openTime;
| |
double openPrice;
| |
double stopLoss;
| |
double takeProfit;
| |
datetime closeTime;
| |
double closePrice;
| |
datetime expiration;
| |
string comment;
| |
double point;
| |
};
| |
| |
//+------------------------------------------------------------------+
| |
//| Класс виртуальных ордеров и позиций |
| |
//+------------------------------------------------------------------+
| |
class CVirtualOrder {
| |
private:
| |
//--- Статические поля
| |
static ulong s_count; // Счётчик всех созданных объектов CVirtualOrder
| |
static ulong s_ticket;
| |
CSymbolInfo *m_symbolInfo; // Объект для получения свойств символов
| |
| |
//--- Связанные объекты получателя и стратегии
| |
CSymbolsMonitor *m_symbols;
| |
CVirtualReceiver *m_receiver;
| |
CVirtualStrategy *m_strategy;
| |
| |
//--- Свойства ордера (позиции)
| |
ulong m_id; // ID
| |
ulong m_ticket; // Тикет
| |
string m_symbol; // Символ
| |
double m_lot; // Объем
| |
ENUM_ORDER_TYPE m_type; // Тип
| |
double m_openPrice; // Цена открытия
| |
double m_stopLoss; // Уровень StopLoss
| |
double m_takeProfit; // Уровень TakeProfit
| |
string m_comment; // Комментарий
| |
datetime m_expiration; // Время истечения
| |
| |
datetime m_openTime; // Время открытия
| |
| |
//--- Свойства закрытого ордера (позиции)
| |
double m_closePrice; // Цена закрытия
| |
datetime m_closeTime; // Время закрытия
| |
string m_closeReason; // Причина закрытия
| |
| |
double m_point; // Величина пункта
| |
| |
bool m_isStopLoss; // Признак срабатывания StopLoss
| |
bool m_isTakeProfit; // Признак срабатывания TakeProfit
| |
bool m_isExpired; // Признак истечения времени
| |
| |
//--- Частные методы
| |
bool CheckClose(); // Проверка условий закрытия
| |
bool CheckTrigger(); // Проверка срабатывания отложенного ордера
| |
| |
public:
| |
CVirtualOrder(
| |
CVirtualStrategy *p_strategy
| |
); // Конструктор
| |
| |
~CVirtualOrder() {
| |
if(!!m_symbolInfo) delete m_symbolInfo;
| |
}
| |
| |
//--- Методы проверки состояния позиции (ордера)
| |
bool IsOpen() { // Ордер открыт?
| |
return(this.m_openTime > 0 && this.m_closeTime == 0);
| |
};
| |
bool IsClosed() { // Ордер закрыт?
| |
return(this.m_openTime > 0 && this.m_closeTime > 0);
| |
};
| |
bool IsMarketOrder() { // Это рыночная позиция?
| |
return IsOpen() && (m_type == ORDER_TYPE_BUY || m_type == ORDER_TYPE_SELL);
| |
}
| |
bool IsPendingOrder() {// Это отложенный ордер?
| |
return IsOpen() && (m_type == ORDER_TYPE_BUY_LIMIT
| |
|| m_type == ORDER_TYPE_BUY_STOP
| |
|| m_type == ORDER_TYPE_SELL_LIMIT
| |
|| m_type == ORDER_TYPE_SELL_STOP);
| |
}
| |
bool IsBuyOrder() { // Это открытая позиция BUY?
| |
return IsOpen() && (m_type == ORDER_TYPE_BUY
| |
|| m_type == ORDER_TYPE_BUY_LIMIT
| |
|| m_type == ORDER_TYPE_BUY_STOP);
| |
}
| |
bool IsSellOrder() { // Это открытая позиция SELL?
| |
return IsOpen() && (m_type == ORDER_TYPE_SELL
| |
|| m_type == ORDER_TYPE_SELL_LIMIT
| |
|| m_type == ORDER_TYPE_SELL_STOP);
| |
}
| |
bool IsStopOrder() { // Это отложенный STOP-ордер?
| |
return IsOpen() && (m_type == ORDER_TYPE_BUY_STOP || m_type == ORDER_TYPE_SELL_STOP);
| |
}
| |
bool IsLimitOrder() { // Это отложенный LIMIT-ордер?
| |
return IsOpen() && (m_type == ORDER_TYPE_BUY_LIMIT || m_type == ORDER_TYPE_SELL_LIMIT);
| |
}
| |
| |
//--- Методы получения свойств позиции (ордера)
| |
ulong Id() { // ID
| |
return m_id;
| |
}
| |
ulong Ticket() { // Тикет
| |
return m_ticket;
| |
}
| |
CStrategy *Strategy() {
| |
return m_strategy;
| |
}
| |
ENUM_ORDER_TYPE Type() {
| |
return m_type;
| |
}
| |
string TypeName() {
| |
string s = StringSubstr(EnumToString(m_type), 11);
| |
StringReplace(s, "_", " ");
| |
return s;
| |
}
| |
double Lot() {
| |
return m_lot;
| |
}
| |
double Volume() { // Объем с направлением
| |
return IsBuyOrder() ? m_lot : (IsSellOrder() ? -m_lot : 0);
| |
}
| |
double Profit(); // Текущая прибыль
| |
double ClosedProfit();
| |
| |
string Symbol() { // Символ
| |
return m_symbol;
| |
}
| |
double OpenPrice() {
| |
return m_openPrice;
| |
}
| |
datetime OpenTime() {
| |
return m_openTime;
| |
}
| |
double ClosePrice() {
| |
return m_closePrice;
| |
}
| |
datetime CloseTime() {
| |
return m_closeTime;
| |
}
| |
double FittedBalance() {
| |
return m_strategy.FittedBalance();
| |
}
| |
double StopLoss() {
| |
return m_stopLoss;
| |
}
| |
void StopLoss(double value) {
| |
m_stopLoss = value;
| |
}
| |
double TakeProfit() {
| |
return m_takeProfit;
| |
}
| |
void TakeProfit(double value) {
| |
m_takeProfit = value;
| |
}
| |
| |
//--- Методы обработки позиций (ордеров)
| |
bool CVirtualOrder::Open(string symbol,
| |
ENUM_ORDER_TYPE type,
| |
double lot,
| |
double price,
| |
double sl = 0,
| |
double tp = 0,
| |
string comment = "",
| |
datetime expiration = 0,
| |
bool inPoints = false); // Открытие позиции (ордера)
| |
| |
void Expiration(datetime p_expiration) {
| |
if(IsOpen()) {
| |
m_expiration = p_expiration;
| |
}
| |
}
| |
| |
void Tick(); // Обработка тика для позиции (ордера)
| |
void Close(); // Закрытие позиции (ордера)
| |
void Clear() {
| |
m_lot = 0;
| |
}
| |
| |
virtual void Load(const VirtualOrderStruct &o); // Загрузка состояния
| |
virtual void Save(VirtualOrderStruct &o); // Сохранение состояния
| |
| |
static void Reset() {
| |
s_count = 0;
| |
}
| |
| |
// Есть ли открытые рыночные виртуальные позиции?
| |
static bool HasMarket(CVirtualOrder* &p_orders[]);
| |
| |
string operator~(); // Преобразование объекта в строку
| |
};
| |
| |
// Инициализация статических полей класса
| |
ulong CVirtualOrder::s_count = 0;
| |
ulong CVirtualOrder::s_ticket = 0;
| |
| |
//+------------------------------------------------------------------+
| |
//| Конструктор |
| |
//+------------------------------------------------------------------+
| |
CVirtualOrder::CVirtualOrder(CVirtualStrategy *p_strategy) :
| |
// Список инициализации
| |
m_id(++s_count), // Новый идентификатор = счётчик объектов + 1
| |
m_ticket(0),
| |
m_receiver(CVirtualReceiver::Instance()),
| |
m_strategy(p_strategy),
| |
m_symbol(""),
| |
m_lot(0),
| |
m_type(-1),
| |
m_openPrice(0),
| |
m_stopLoss(0),
| |
m_takeProfit(0),
| |
m_openTime(0),
| |
m_comment(""),
| |
m_expiration(0),
| |
m_closePrice(0),
| |
m_closeTime(0),
| |
m_closeReason(""),
| |
m_point(0) {
| |
PrintFormat(__FUNCTION__ + "#%d | CREATED VirtualOrder", m_id);
| |
m_symbolInfo = NULL;
| |
m_symbols = CSymbolsMonitor::Instance();
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Открытие виртуальной позиции (ордера) |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualOrder::Open(string symbol, // Символ
| |
ENUM_ORDER_TYPE type, // Тип (BUY или SELL)
| |
double lot, // Объём
| |
double price = 0, // Цена открытия
| |
double sl = 0, // Уровень StopLoss (цена или пункты)
| |
double tp = 0, // Уровень TakeProfit (цена или пункты)
| |
string comment = "", // Комментарий
| |
datetime expiration = 0, // Время истечения
| |
bool inPoints = false // Уровни SL и TP заданы в пунктах?
| |
) {
| |
if(IsOpen()) { // Если позиция уже открыта, то ничего не делаем
| |
PrintFormat(__FUNCTION__ "#%d | ERROR: Order is opened already!", m_id);
| |
return false;
| |
}
| |
| |
// Получаем от монитора символов указатель на информационный объект для нужного символа
| |
m_symbolInfo = m_symbols[symbol];
| |
| |
if(!!m_symbolInfo) {
| |
//m_symbolInfo.RefreshRates(); // Обновляем информацию о текущих ценах
| |
| |
// Инициализируем свойства позиции
| |
m_ticket = ++s_ticket;
| |
m_openPrice = price;
| |
m_symbol = symbol;
| |
m_lot = lot;
| |
m_openTime = TimeCurrent();
| |
m_closeTime = 0;
| |
m_type = type;
| |
m_comment = comment;
| |
m_expiration = expiration;
| |
| |
// Открываемая позиция (ордер) не является закрытой по SL, TP или истечению
| |
m_isStopLoss = false;
| |
m_isTakeProfit = false;
| |
m_isExpired = false;
| |
| |
m_point = m_symbolInfo.Point();
| |
| |
double bid = m_symbolInfo.Bid();
| |
double ask = m_symbolInfo.Ask();
| |
double spread = ((ask - bid) / m_point);
| |
| |
//m_symbolInfo.Spread();
| |
| |
// В зависимости от направления устанавливаем цену открытия и уровни SL и TP.
| |
// Если SL и TP заданы в пунктах, то предварительно вычисляем их ценовые уровни
| |
// относительно цены открытия
| |
if(IsBuyOrder()) {
| |
if(type == ORDER_TYPE_BUY) {
| |
m_openPrice = ask;
| |
}
| |
m_stopLoss = (sl > 0 ? (inPoints ? m_openPrice - sl * m_point - spread * m_point : sl) : 0);
| |
m_takeProfit = (tp > 0 ? (inPoints ? m_openPrice + tp * m_point : tp) : 0);
| |
} else if(IsSellOrder()) {
| |
if(type == ORDER_TYPE_SELL) {
| |
m_openPrice = bid;
| |
}
| |
m_stopLoss = (sl > 0 ? (inPoints ? m_openPrice + sl * m_point : sl) : 0);
| |
m_takeProfit = (tp > 0 ? (inPoints ? m_openPrice - tp * m_point - spread * m_point : tp) : 0);
| |
}
| |
| |
// Оповещаем получатель и стратегию, что позиция (ордер) открыта
| |
m_receiver.OnOpen(&this);
| |
m_strategy.OnOpen(&this);
| |
| |
PrintFormat(__FUNCTION__"#%d | OPEN %s: %s %s %.2f | Price=%.5f | SL=%.5f | TP=%.5f | %s | %s",
| |
m_id, (IsMarketOrder() ? "Market" : "Pending"), StringSubstr(EnumToString(type), 11),
| |
m_symbol, m_lot, m_openPrice, m_stopLoss, m_takeProfit, m_comment,
| |
(m_expiration ? TimeToString(m_expiration) : "-"));
| |
| |
return true;
| |
} else {
| |
PrintFormat(__FUNCTION__"#%d | ERROR: Can't find symbol %s for "
| |
"OPEN %s: %s %s %.2f | Price=%.5f | SL=%.5f | TP=%.5f | %s | %s",
| |
m_id, m_symbol, (IsMarketOrder() ? "Market" : "Pending"), StringSubstr(EnumToString(type), 11),
| |
m_symbol, m_lot, m_openPrice, m_stopLoss, m_takeProfit, m_comment,
| |
(m_expiration ? TimeToString(m_expiration) : "-"));
| |
return false;
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Закрытие позиции |
| |
//+------------------------------------------------------------------+
| |
void CVirtualOrder::Close() {
| |
if(IsOpen()) { // Если позиция открыта
| |
// Определяем причину закрытия для вывода в лог
| |
string closeReason = "";
| |
| |
if(m_isStopLoss) {
| |
closeReason += "[SL]";
| |
} else if(m_isTakeProfit) {
| |
closeReason += "[TP]";
| |
} else if(m_isExpired) {
| |
closeReason += "[EX]";
| |
} else {
| |
closeReason += "[CL]";
| |
}
| |
| |
PrintFormat(__FUNCTION__ + "#%d | CLOSE %s: %s %s %.2f | Profit=%.2f %s | %s",
| |
m_id, (IsMarketOrder() ? "Market" : "Pending"), StringSubstr(EnumToString(m_type), 11),
| |
m_symbol, m_lot, Profit(), closeReason, m_comment);
| |
| |
m_closeTime = TimeCurrent(); // Время закрытия позиции
| |
| |
// Запоминаем цену закрытия в зависимости от типа
| |
if(m_type == ORDER_TYPE_BUY) {
| |
m_closePrice = m_symbolInfo.Bid();
| |
} else if(m_type == ORDER_TYPE_SELL) {
| |
m_closePrice = m_symbolInfo.Ask();
| |
} else {
| |
m_closePrice = 0;
| |
}
| |
| |
// Оповещаем получатель и стратегию, что позиция (ордер) закрыта
| |
m_receiver.OnClose(&this);
| |
m_strategy.OnClose(&this);
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Расчет текущей прибыли позиции |
| |
//+------------------------------------------------------------------+
| |
double CVirtualOrder::Profit() {
| |
double profit = 0;
| |
if(IsMarketOrder()) { // Если это открытая рыночная виртуальная позиция
| |
//m_symbolInfo.Name(m_symbol); // Выбираем нужный символ
| |
//m_symbolInfo.RefreshRates(); // Обновляем информацию о текущих ценах
| |
| |
// Текущая цена, по которой можно закрыть позицию
| |
double closePrice = (m_type == ORDER_TYPE_BUY) ? m_symbolInfo.Bid() : m_symbolInfo.Ask();
| |
| |
// Прибыль в виде разности цен открытия и закрытия
| |
if(m_type == ORDER_TYPE_BUY) {
| |
profit = closePrice - m_openPrice;
| |
} else {
| |
profit = m_openPrice - closePrice;
| |
}
| |
| |
if(m_point > 1e-10) { // Если известен размер пункта, то
| |
// Пересчитываем прибыль из разности цен в денежное выражение для объёма в 1 лот
| |
if(profit > 0) {
| |
profit = profit / m_point * m_symbolInfo.TickValueProfit();
| |
} else {
| |
profit = profit / m_point * m_symbolInfo.TickValueLoss();
| |
}
| |
} else {
| |
PrintFormat(__FUNCTION__ + "#%d | ERROR: Point for %s is undefined", m_id, m_symbol);
| |
m_point = m_symbolInfo.Point();
| |
}
| |
// Пересчитываем прибыль для объёма позиции
| |
profit *= m_lot;
| |
}
| |
| |
return profit;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
double CVirtualOrder::ClosedProfit() {
| |
double profit = 0;
| |
if(IsClosed()) {
| |
| |
// Если это открытая рыночная виртуальная позиция
| |
//s_symbolInfo.Name(m_symbol); // Выбираем нужный символ
| |
//s_symbolInfo.RefreshRates(); // Обновляем информацию о текущих ценах
| |
| |
// Текущая цена, по которой можно закрыть позицию
| |
double closePrice = m_closePrice;
| |
| |
// Прибыль в виде разности цен открытия и закрытия
| |
if(m_type == ORDER_TYPE_BUY) {
| |
profit = closePrice - m_openPrice;
| |
} else if(m_type == ORDER_TYPE_SELL) {
| |
profit = m_openPrice - closePrice;
| |
}
| |
| |
if(m_point > 1e-10) { // Если известен размер пункта, то
| |
// Пересчитываем прибыль из разности цен в денежное выражение для объёма в 1 лот
| |
if(profit > 0) {
| |
profit = profit / m_point * m_symbolInfo.TickValueProfit();
| |
} else {
| |
profit = profit / m_point * m_symbolInfo.TickValueLoss();
| |
}
| |
} else {
| |
PrintFormat(__FUNCTION__ + "#%d | ERROR: Point for %s is undefined", m_id, m_symbol);
| |
m_point = m_symbolInfo.Point();
| |
}
| |
// Пересчитываем прибыль для объёма позиции
| |
profit *= m_lot;
| |
}
| |
| |
return profit;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка необходимости закрытия по SL, TP или EX |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualOrder::CheckClose() {
| |
if(IsMarketOrder()) { // Если это открытая рыночная виртуальная позиция, то
| |
//s_symbolInfo.Name(m_symbol); // Выбираем нужный символ
| |
//s_symbolInfo.RefreshRates(); // Обновляем информацию о текущих ценах
| |
| |
// Текущая цена, по которой можно закрыть позицию
| |
double closePrice = (m_type == ORDER_TYPE_BUY) ? m_symbolInfo.Bid() : m_symbolInfo.Ask();
| |
//double spread = m_symbolInfo.Spread();
| |
//double lastHigh = iHigh(m_symbol, PERIOD_M1, 1);
| |
//double lastLow = iLow(m_symbol, PERIOD_M1, 1) + spread;
| |
| |
bool res = false;
| |
// Проверяем, что цена достигла SL или TP
| |
if(m_type == ORDER_TYPE_BUY) {
| |
m_isStopLoss = (m_stopLoss > 0 && closePrice <= m_stopLoss);
| |
m_isTakeProfit = (m_takeProfit > 0 && (closePrice >= m_takeProfit
| |
//|| lastHigh >= m_takeProfit
| |
));
| |
} else if(m_type == ORDER_TYPE_SELL) {
| |
m_isStopLoss = (m_stopLoss > 0 && closePrice >= m_stopLoss);
| |
m_isTakeProfit = (m_takeProfit > 0 && (closePrice <= m_takeProfit
| |
// || lastLow <= m_takeProfit
| |
));
| |
}
| |
| |
// Был ли достигнут SL или TP?
| |
res = (m_isStopLoss || m_isTakeProfit);
| |
| |
if(res) {
| |
PrintFormat(__FUNCTION__ + "#%d | %s REACHED at %.5f: %.5f | %.5f, Profit=%.2f | %s",
| |
m_id, (m_isStopLoss ? "SL" : "TP"), closePrice, m_stopLoss, m_takeProfit,
| |
Profit(), m_comment);
| |
return true;
| |
}
| |
} else if(IsPendingOrder()) { // Если это виртуальный отложенный ордер
| |
// Проверяем, было ли достигнуто время истечения, если оно задано
| |
if(m_expiration > 0 && m_expiration < TimeCurrent()) {
| |
m_isExpired = true;
| |
return true;
| |
}
| |
}
| |
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Обработка тика одного виртуального ордера (позиции) |
| |
//+------------------------------------------------------------------+
| |
void CVirtualOrder::Tick() {
| |
if(IsOpen()) { // Если это открытая виртуальная позиция или ордер
| |
if(CheckClose()) { // Проверяем, достигнуты ли уровни SL или TP или время истечения
| |
Close(); // Закрываем при достижении
| |
} else if (IsPendingOrder()) { // Если это отложенный ордер
| |
CheckTrigger(); // Проверяем его срабатывание
| |
}
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Проверка срабатывания отложенного ордера |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualOrder::CheckTrigger() {
| |
if(IsPendingOrder()) {
| |
//m_symbolInfo.Name(m_symbol); // Выбираем нужный символ
| |
//m_symbolInfo.RefreshRates(); // Обновляем информацию о текущих ценах
| |
double bid = m_symbolInfo.Bid();
| |
double ask = m_symbolInfo.Ask();
| |
double spread = ((ask - bid) / m_point);
| |
| |
double price = (IsBuyOrder()) ? ask : bid;
| |
| |
| |
// Если цена дошла до уровней открытия, то превращаем ордер в позицию
| |
if(false
| |
|| (m_type == ORDER_TYPE_BUY_LIMIT && price <= m_openPrice)
| |
|| (m_type == ORDER_TYPE_BUY_STOP && price >= m_openPrice)
| |
) {
| |
PrintFormat(__FUNCTION__"#%d | OPEN %s at %.5f -> BUY at %.5f (Spread: %.0f)",
| |
m_id, StringSubstr(EnumToString(m_type), 11), m_openPrice, price, spread);
| |
m_type = ORDER_TYPE_BUY;
| |
} else if(false
| |
|| (m_type == ORDER_TYPE_SELL_LIMIT && price >= m_openPrice)
| |
|| (m_type == ORDER_TYPE_SELL_STOP && price <= m_openPrice)
| |
) {
| |
PrintFormat(__FUNCTION__"#%d | OPEN %s at %.5f -> SELL at %.5f (Spread: %.0f)",
| |
m_id, StringSubstr(EnumToString(m_type), 11), m_openPrice, price, spread);
| |
m_type = ORDER_TYPE_SELL;
| |
}
| |
| |
// Если ордер превратился в позицию
| |
if(IsMarketOrder()) {
| |
m_openPrice = price; // Запоминаем цену открытия
| |
| |
// Оповещаем получатель и стратегию, что открыта позиция
| |
m_receiver.OnOpen(&this);
| |
m_strategy.OnOpen(&this);
| |
return true;
| |
}
| |
}
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Сохранение состояния |
| |
//+------------------------------------------------------------------+
| |
void CVirtualOrder::Save(VirtualOrderStruct &o) {
| |
o.ticket = m_ticket;
| |
o.symbol = m_symbol;
| |
o.lot = m_lot;
| |
o.type = m_type;
| |
o.openPrice = m_openPrice;
| |
o.stopLoss = m_stopLoss;
| |
o.takeProfit = m_takeProfit;
| |
o.openTime = m_openTime;
| |
o.closePrice = m_closePrice;
| |
o.closeTime = m_closeTime;
| |
o.expiration = m_expiration;
| |
o.comment = m_comment;
| |
o.point = m_point;
| |
}
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Загрузка состояния |
| |
//+------------------------------------------------------------------+
| |
void CVirtualOrder::Load(const VirtualOrderStruct &o) {
| |
m_ticket = o.ticket;
| |
m_symbol = o.symbol;
| |
m_lot = o.lot;
| |
m_type = o.type;
| |
m_openPrice = o.openPrice;
| |
m_stopLoss = o.stopLoss;
| |
m_takeProfit = o.takeProfit;
| |
m_openTime = o.openTime;
| |
m_closePrice = o.closePrice;
| |
m_closeTime = o.closeTime;
| |
m_expiration = o.expiration;
| |
m_comment = o.comment;
| |
m_point = o.point;
| |
| |
PrintFormat(__FUNCTION__" | %s", ~this);
| |
| |
s_ticket = MathMax(s_ticket, m_ticket);
| |
| |
m_symbolInfo = m_symbols[m_symbol];
| |
| |
// Оповещаем получатель и стратегию, что позиция (ордер) открыта
| |
if(IsOpen()) {
| |
m_receiver.OnOpen(&this);
| |
m_strategy.OnOpen(&this);
| |
} else {
| |
m_receiver.OnClose(&this);
| |
m_strategy.OnClose(&this);
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Есть ли открытые рыночные виртуальные позиции? |
| |
//+------------------------------------------------------------------+
| |
bool CVirtualOrder::HasMarket(CVirtualOrder *&p_orders[]) {
| |
FOREACH(p_orders) if (p_orders[i].IsMarketOrder()) return true;
| |
return false;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Преобразование объекта в строку |
| |
//+------------------------------------------------------------------+
| |
string CVirtualOrder::operator~() {
| |
if(IsOpen()) {
| |
return StringFormat("#%d %s %s %.2f in %s at %.5f (%.5f, %.5f). %s, %f",
| |
m_id, TypeName(), m_symbol, m_lot,
| |
TimeToString(m_openTime), m_openPrice,
| |
m_stopLoss, m_takeProfit,
| |
TimeToString(m_closeTime), m_closePrice);
| |
} else {
| |
return StringFormat("#%d --- ", m_id);
| |
}
| |
| |
}
| |
//+------------------------------------------------------------------+
|