RoyFaldo/MQLArticles
Watch
1
0
Fork
You've already forked MQLArticles
 0
forked from nique_372/MQLArticles
Code Pull requests Activity
MQLArticles/RM/RM_Functions.mqh
Nique_372 8befa48b50
2026-01-29 10:49:55 -05:00

870 lines
57 KiB
MQL5
RawPermalinkBlameHistory

//+------------------------------------------------------------------+
//| RMt_Functions.mqh |
//| Niquel y Leo, Copyright 2025 |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Niquel y Leo, Copyright 2025"
#property link "https://www.mql5.com"
#property strict
#ifndef MQLARTICLES_RM_RFUNCTIONS_MQH
#define MQLARTICLES_RM_RFUNCTIONS_MQH
#include "LoteSizeCalc.mqh"
//+-------------------------------------------------------------------------------------------------+
//+----------------------------------- Functions -------------------------------------+
//+-------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
double GetPositionCommission(ulong ticket)
{
// Verificar si la posición existe y obtener su tiempo de apertura
if(!PositionSelectByTicket(ticket))
{
Print("Error: Posición con ticket ", ticket, " no encontrada");
return 0.0;
}
datetime open_time = (datetime)PositionGetInteger(POSITION_TIME);
// Usar un rango de tiempo estrecho: desde el tiempo de apertura hasta 1 segundo después
if(!HistorySelect(open_time, open_time + 1))
{
Print("Error: No se pudo cargar el historial de deals para el ticket ", ticket);
return 0.0;
}
// Obtener el primer deal del historial
ulong deal_ticket = HistoryDealGetTicket(0);
if(deal_ticket == 0)
{
Print("Error: No se encontró un deal para el ticket ", ticket);
return 0.0;
}
// Verificar si el deal corresponde a la posición y es de entrada
if(HistoryDealGetInteger(deal_ticket, DEAL_POSITION_ID) == ticket)
{
ENUM_DEAL_TYPE deal_type = (ENUM_DEAL_TYPE)HistoryDealGetInteger(deal_ticket, DEAL_TYPE);
if(deal_type == DEAL_TYPE_BUY || deal_type == DEAL_TYPE_SELL)
{
return HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);
}
}
Print("Error: No se encontró un deal de apertura válido para el ticket ", ticket);
return 0.0;
}
//+------------------------------------------------------------------+
inline CGetLote* CreateLotePtr(string symbol)
{
CGetLote* l = new CGetLote(symbol);
return l;
}
//+------------------------------------------------------------------+
double GetTotalPositionProfitNoCurrent(ulong position_ticket)
{
double total_profit = 0.0;
//---
if(HistorySelectByPosition(position_ticket))
{
int deals_count = HistoryDealsTotal();
for(int i = 0; i < deals_count; i++)
{
ulong deal_ticket = HistoryDealGetTicket(i);
if(deal_ticket <= 0)
continue;
ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(deal_ticket, DEAL_ENTRY);
if(entry == DEAL_ENTRY_OUT || entry == DEAL_ENTRY_IN)
{
total_profit += HistoryDealGetDouble(deal_ticket, DEAL_PROFIT) +
HistoryDealGetDouble(deal_ticket, DEAL_SWAP) +
HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);
}
}
}
return total_profit;
}
//+------------------------------------------------------------------+
//| Retrieve the magic number associated with a ticket |
//+------------------------------------------------------------------+
inline ulong GetMagic(const ulong ticket)
{
HistoryOrderSelect(ticket);
return HistoryOrderGetInteger(ticket, ORDER_MAGIC);
}
//+----------------------------------------------------------------------------------------+
//| Calculates the net profit since a given date for a specific magic number or all trades |
//+----------------------------------------------------------------------------------------+
const bool GetNetProfitOmitirDeal[18] =
{
false, //compra
false, //venta
true, //balance
true, //credito
true, //carga adicionales
false, //correcion
true, //bonos
false, //comisiones adicional
false, //comisions del dia
false, //comision del mes
false, //comosions agente dia
false, //comosiion agenet mes,
false, //interes
false, //compra cancelada
false, //ventan cancelada
false, //dividendo
false, //dividendo frankeado, con beneficions
false //impuestos
};
//---
double GetNetProfitSince(bool include_all_magic, ulong specific_magic, datetime start_date)
{
double total_net_profit = 0.0; // Initialize the total net profit
ResetLastError(); // Reset any previous errors
//---
if(start_date > 0 && start_date != D'1971.01.01 00:00')
{
if(!HistorySelect(start_date, TimeCurrent()))
{
Print("Error when selecting orders: ", _LastError);
return 0.00; // Exit if unable to select the history
}
const int total_deals = HistoryDealsTotal(); // Count total deals in the history
for(int i = 0; i < total_deals; i++)
{
const ulong deal_ticket = HistoryDealGetTicket(i); // Get the deal ticket
if(GetNetProfitOmitirDeal[HistoryDealGetInteger(deal_ticket, DEAL_TYPE)])
continue;
//---
const ulong deal_magic = HistoryDealGetInteger(deal_ticket, DEAL_MAGIC);
if(!include_all_magic && deal_magic != specific_magic)
continue;
//---
const double deal_profit = HistoryDealGetDouble(deal_ticket, DEAL_PROFIT);
const double deal_commission = HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);
const double deal_swap = HistoryDealGetDouble(deal_ticket, DEAL_SWAP);
total_net_profit += (deal_profit + deal_commission + deal_swap);
}
}
//---
return total_net_profit;
}
//+------------------------------------------------------------------+
//| Function to close orders |
//+------------------------------------------------------------------+
// Converts an order type to its corresponding flag
#define OrderTypeToFlag(type) OrdensToFlagArray[type]
const int ALL_FLAGS_STOPS = FLAG_ORDER_TYPE_BUY_STOP | FLAG_ORDER_TYPE_SELL_STOP;
const int ALL_FLAGS_LIMITS = FLAG_ORDER_TYPE_BUY_LIMIT | FLAG_ORDER_TYPE_SELL_LIMIT;
const int ALL_FLAGS_ORDERS = (FLAG_ORDER_TYPE_BUY | FLAG_ORDER_TYPE_SELL | FLAG_ORDER_TYPE_BUY_LIMIT |
FLAG_ORDER_TYPE_SELL_LIMIT | FLAG_ORDER_TYPE_BUY_STOP | FLAG_ORDER_TYPE_SELL_STOP |
FLAG_ORDER_TYPE_BUY_STOP_LIMIT | FLAG_ORDER_TYPE_SELL_STOP_LIMIT | FLAG_ORDER_TYPE_CLOSE_BY);
// Close all orders that match the flags in `flags`
void CloseAllOrders(int flags, CTrade & obj_trade, ulong magic_number_ = NOT_MAGIC_NUMBER)
{
ResetLastError();
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i);
if(OrderSelect(ticket))
{
ENUM_ORDER_TYPE type_order = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
ulong magic = OrderGetInteger(ORDER_MAGIC);
int bandera = OrderTypeToFlag(type_order);
if((bandera & flags) != 0 && (magic == magic_number_ || magic_number_ == NOT_MAGIC_NUMBER))
{
if(type_order == ORDER_TYPE_BUY || type_order == ORDER_TYPE_SELL)
obj_trade.PositionClose(ticket);
else
obj_trade.OrderDelete(ticket);
}
}
else
{
PrintFormat("Error selecting order %d, last error %d", ticket, GetLastError());
}
}
}
//+------------------------------------------------------------------+
//| Function to obtain the positions opened by the EA or user |
//+------------------------------------------------------------------+
int PositionTypeToFlag(ENUM_POSITION_TYPE type)
{
if(type == POSITION_TYPE_BUY)
return FLAG_POSITION_TYPE_BUY;
else
if(type == POSITION_TYPE_SELL)
return FLAG_POSITION_TYPE_SELL;
return FLAG_POSITION_TYPE_BUY | FLAG_POSITION_TYPE_SELL;
}
//---
int Get_Positions(int flags = FLAG_POSITION_TYPE_BUY | FLAG_POSITION_TYPE_SELL, ulong magic_number_ = NOT_MAGIC_NUMBER)
{
int counter = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong position_ticket = PositionGetTicket(i);
if(!PositionSelectByTicket(position_ticket))
continue; // Si la selección falla, pasa a la siguiente posición
ulong position_magic = PositionGetInteger(POSITION_MAGIC);
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
// Check if the position type matches the flags
if((flags & PositionTypeToFlag(type)) != 0 &&
(position_magic == magic_number_ || magic_number_ == NOT_MAGIC_NUMBER))
{
counter++;
}
}
return counter;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
template<typename T>
bool RemoveIndexFromAnArrayOfPositions(T & array[], const ulong ticket, int reserve)
{
const int size = ArraySize(array);
int index = -1;
// Search index and move elements in a single loop
for(int i = 0; i < size; i++)
{
if(array[i].ticket == ticket)
{
index = i;
}
if(index != -1 && i < size - 1)
{
array[i] = array[i + 1]; // Move the elements
}
}
if(index == -1)
return false;
// Reducir el tamaño del array
ArrayResize(array, size - 1, reserve);
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void PrintArrayAsTable(double & array[], string fila_descripcion, string columna_prefijo = "Valor")
{
string header = fila_descripcion;
int len = StringLen(header);
string values = StringRepeat(" ", len + 2);
int max_len = StringLen(header);
for(int i = 0; i < ArraySize(array); i++)
{
string col_name = columna_prefijo + " " + IntegerToString(i + 1);
max_len = MathMax(max_len, StringLen(col_name));
}
header = StringFormat("%-" + (string)(max_len + 2) + "s", header);
for(int i = 0; i < ArraySize(array); i++)
{
string col_name = columna_prefijo + " " + IntegerToString(i + 1);
header += StringFormat("| %-10s ", col_name);
values += StringFormat("| %-10.2f ", array[i]);
}
Print(header);
Print(values);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void SetDynamicUsingFixedParameters(
double _balance_percentage_to_activate_the_risk_1, double _balance_percentage_to_activate_the_risk_2, double _balance_percentage_to_activate_the_risk_3, double _balance_percentage_to_activate_the_risk_4,
double _percentage_to_be_modified_1, double _percentage_to_be_modified_2, double _percentage_to_be_modified_3, double _percentage_to_be_modified_4,
string & percentages_to_activate, string & risks_to_be_applied)
{
percentages_to_activate = DoubleToString(_balance_percentage_to_activate_the_risk_1) + "," + DoubleToString(_balance_percentage_to_activate_the_risk_2) + "," + DoubleToString(_balance_percentage_to_activate_the_risk_3)
+ "," + DoubleToString(_balance_percentage_to_activate_the_risk_4);
risks_to_be_applied = DoubleToString(_percentage_to_be_modified_1) + "," + DoubleToString(_percentage_to_be_modified_2) + "," + DoubleToString(_percentage_to_be_modified_3)
+ "," + DoubleToString(_percentage_to_be_modified_4);
}
//+------------------------------------------------------------------+
//| Clase CTicketsInfo |
//+------------------------------------------------------------------+
Position EMPTY_POSITION;
//---
class CTicketsInfo : public CLoggerBase
{
private:
//--- Data
Position m_positions[];
//--- Hash
uint16_t m_hash_table[];
bool m_hash_filled[];
uint16_t m_hash_size;
uint16_t m_hash_count;
//--- Static
static const float LOAD_FACTOR_LIMIT;
static const uint16_t INITIAL_HASH_SIZE;
//--- Internal functions
int16_t FindHash(const ulong ticket) const;
bool InsertHash(ulong ticket, uint16_t pos_idx);
bool RemoveHash(ulong ticket);
void UpdateHashAfterSwap(ulong ticket, uint16_t new_pos_idx);
void ResizeHashTable();
bool IsPrime(uint16_t n);
public:
CTicketsInfo(void);
~CTicketsInfo(void);
//--- Data
// Get
bool GetByTicket(const ulong ticket, Position& pos, int16_t& out_idx) const;
bool GetByTicket(const ulong ticket, Position& pos) const;
inline Position GetByTicket(const ulong ticket) const;
inline Position GetByIndex(const int16_t index) const { return m_positions[index]; }
// Delete
bool DeleteByIndex(const int16_t pos_idx);
bool DeleteByTicket(const ulong ticket);
bool DeleteByTicket(const ulong ticket, Position &position);
// Add
bool Add(Position &p);
// Update
inline void UpdatePositionPartial(double net, double close_volume, int16_t pos_idx);
inline void UpdateTp(double new_tp, ulong ticket);
inline void UpdateSl(double new_sl, ulong ticket);
//--- General Getters
// Index
inline bool IsValidIdx(int16_t index) const; // Is Valid index
__forceinline int GetIndex(const ulong ticket) const { return FindHash(ticket);}
// Total
__forceinline int16_t Total() const { return (int16_t)ArraySize(m_positions); }
__forceinline uint16_t TotalU() const { return (uint16_t)m_positions.Size(); }
//--- Exist
inline bool Exists(const ulong ticket) const;
//--- Free
void Free();
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
const float CTicketsInfo::LOAD_FACTOR_LIMIT = 0.7f;
const uint16_t CTicketsInfo::INITIAL_HASH_SIZE = 9973;
#define CTicketsInfo_HashTicket(ticket) uint16_t(ticket % m_hash_size)
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CTicketsInfo::CTicketsInfo(void) : m_hash_size(INITIAL_HASH_SIZE), m_hash_count(0)
{
ArrayResize(m_hash_table, m_hash_size);
ArrayResize(m_hash_filled, m_hash_size);
ArrayInitialize(m_hash_table, 65535);
ArrayInitialize(m_hash_filled, false);
}
//+------------------------------------------------------------------+
CTicketsInfo::~CTicketsInfo(void)
{
ArrayFree(m_positions);
ArrayFree(m_hash_table);
ArrayFree(m_hash_filled);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
inline bool CTicketsInfo::IsValidIdx(int16_t index) const
{
if(index >= 0 && index < Total())
return true;
LogError(StringFormat("El índice %d es inválido", index), FUNCION_ACTUAL);
return false;
}
//+------------------------------------------------------------------+
int16_t CTicketsInfo::FindHash(const ulong ticket) const
{
//---
const uint16_t h = (uint16_t)(ticket % m_hash_size);
const uint16_t data_size = TotalU();
//---
for(uint16_t i = 0; i < m_hash_size; i++)
{
//---
const uint16_t idx = (h + i) % m_hash_size;
//---
if(!m_hash_filled[idx])
{
LogCaution(StringFormat("El slot del ticket %I64u esta vacio", ticket), FUNCION_ACTUAL);
return -1;
}
//---
const uint16_t pos_idx = m_hash_table[idx];
if(pos_idx != 65535 && pos_idx < data_size && m_positions[pos_idx].ticket == ticket)
{
LogInfo(StringFormat("Ticket %I64u encontrado en idx=%u, pos_idx=%u", ticket, idx, pos_idx), FUNCION_ACTUAL);
return (int16_t)pos_idx;
}
//---
if(pos_idx >= data_size && pos_idx != 65535)
{
LogError(StringFormat("Indice inválido pos_idx=%u para ticket %I64u en idx=%u", pos_idx, ticket, idx), FUNCION_ACTUAL);
return -1;
}
}
//---
LogWarning(StringFormat("El ticket %I64u no se ha encontrado tras recorrer toda la tabla", ticket), FUNCION_ACTUAL);
return -1;
}
//+------------------------------------------------------------------+
bool CTicketsInfo::InsertHash(ulong ticket, uint16_t pos_idx)
{
//---
if((float)(m_hash_count + 1) / m_hash_size > LOAD_FACTOR_LIMIT)
ResizeHashTable();
//---
const uint16_t h = CTicketsInfo_HashTicket(ticket);
for(uint16_t i = 0; i < m_hash_size; i++)
{
const uint16_t idx = (h + i) % m_hash_size;
if(!m_hash_filled[idx])
{
m_hash_table[idx] = pos_idx;
m_hash_filled[idx] = true;
m_hash_count++;
LogInfo(StringFormat("Ticket %I64u insertado en idx=%u, pos_idx=%u", ticket, idx, pos_idx), FUNCION_ACTUAL);
return true;
}
}
//---
LogError(StringFormat("Tabla hash llena para ticket %I64u", ticket), FUNCION_ACTUAL);
return false;
}
//+------------------------------------------------------------------+
bool CTicketsInfo::RemoveHash(ulong ticket)
{
//---
const uint16_t h = CTicketsInfo_HashTicket(ticket);
const uint16_t data_size = TotalU();
//---
for(uint16_t i = 0; i < m_hash_size; i++)
{
//---
const uint16_t idx = (h + i) % m_hash_size;
if(!m_hash_filled[idx])
{
LogCaution(StringFormat("El ticket %I64u no existe (casilla vacía en idx=%u)", ticket, idx), FUNCION_ACTUAL);
return false;
}
//---
const uint16_t pos_idx = m_hash_table[idx];
if(pos_idx != 65535 && pos_idx < data_size && m_positions[pos_idx].ticket == ticket)
{
LogInfo(StringFormat("Se eliminó exitosamente el ticket %I64u en idx=%u, pos_idx=%u", ticket, idx, pos_idx), FUNCION_ACTUAL);
m_hash_filled[idx] = false;
m_hash_table[idx] = 65535;
m_hash_count--;
return true;
}
//---
if(pos_idx >= data_size && pos_idx != 65535)
{
LogError(StringFormat("Índice inválido pos_idx=%u para ticket %I64u en idx=%u", pos_idx, ticket, idx), FUNCION_ACTUAL);
return false;
}
}
//---
LogWarning(StringFormat("El ticket %I64u no se ha encontrado tras recorrer toda la tabla", ticket), FUNCION_ACTUAL);
return false;
}
//+------------------------------------------------------------------+
void CTicketsInfo::UpdateHashAfterSwap(ulong ticket, uint16_t new_pos_idx)
{
//---
const uint16_t h = CTicketsInfo_HashTicket(ticket);
const uint16_t data_size = TotalU();
//---
for(uint16_t i = 0; i < m_hash_size; i++)
{
//---
const uint16_t idx = (h + i) % m_hash_size;
if(!m_hash_filled[idx])
return;
//---
const uint16_t pos_idx = m_hash_table[idx];
if(pos_idx < data_size && m_positions[new_pos_idx].ticket == ticket)
{
m_hash_table[idx] = new_pos_idx;
return;
}
}
}
//+------------------------------------------------------------------+
void CTicketsInfo::ResizeHashTable()
{
//---
LogInfo("Se está aumentando el tamaño de la tabla hash al doble", FUNCION_ACTUAL);
//---
uint16_t new_size = m_hash_size * 2 + 1;
while(!IsPrime(new_size))
new_size += 2;
//---
uint16_t old_hash_table[];
bool old_hash_filled[];
ArrayCopy(old_hash_table, m_hash_table);
ArrayCopy(old_hash_filled, m_hash_filled);
//---
m_hash_size = new_size;
m_hash_count = 0;
ArrayResize(m_hash_table, m_hash_size);
ArrayResize(m_hash_filled, m_hash_size);
ArrayInitialize(m_hash_table, 65535);
ArrayInitialize(m_hash_filled, false);
//---
for(uint16_t i = 0; i < ArraySize(old_hash_table); i++)
{
if(old_hash_filled[i] && old_hash_table[i] != 65535)
{
uint16_t pos_idx = old_hash_table[i];
if(pos_idx < ArraySize(m_positions))
InsertHash(m_positions[pos_idx].ticket, pos_idx);
}
}
//---
ArrayFree(old_hash_table);
ArrayFree(old_hash_filled);
}
//+------------------------------------------------------------------+
bool CTicketsInfo::IsPrime(uint16_t n)
{
if(n < 2)
return false;
for(uint16_t i = 2; i * i <= n; i++)
if(n % i == 0)
return false;
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CTicketsInfo::GetByTicket(const ulong ticket, Position &pos, int16_t &out_idx) const
{
out_idx = FindHash(ticket);
if(out_idx >= 0)
{
pos = m_positions[out_idx];
return true;
}
else
return false;
}
//+------------------------------------------------------------------+
bool CTicketsInfo::GetByTicket(const ulong ticket, Position &pos) const
{
const int16_t pos_idx = FindHash(ticket);
if(pos_idx >= 0)
{
pos = m_positions[pos_idx];
return true;
}
else
return false;
}
//+------------------------------------------------------------------+
inline Position CTicketsInfo::GetByTicket(const ulong ticket) const
{
const int16_t pos_idx = FindHash(ticket);
return pos_idx >= 0 ? m_positions[pos_idx] : EMPTY_POSITION;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
inline void CTicketsInfo::UpdateSl(double new_sl, ulong ticket)
{
const int16_t pos_idx = FindHash(ticket);
if(pos_idx >= 0)
m_positions[pos_idx].sl = new_sl;
}
//+------------------------------------------------------------------+
inline void CTicketsInfo::UpdateTp(double new_tp, ulong ticket)
{
const int16_t pos_idx = FindHash(ticket);
if(pos_idx >= 0)
m_positions[pos_idx].tp = new_tp;
}
//+------------------------------------------------------------------+
inline void CTicketsInfo::UpdatePositionPartial(double net, double close_volume, int16_t pos_idx)
{
if(pos_idx >= 0)
{
m_positions[pos_idx].volume -= close_volume;
m_positions[pos_idx].profit += net;
LogInfo(StringFormat("Volumen cerrado = %.4f (new= %.4f) y profit obtenido = %.2f, al cierra parcial de la posicion = %I64u",
close_volume,
m_positions[pos_idx].volume,
net,
m_positions[pos_idx].ticket), FUNCION_ACTUAL);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CTicketsInfo::Add(Position &p)
{
//---
if(FindHash(p.ticket) >= 0)
{
LogCaution(StringFormat("La posición %I64u ya existe", p.ticket), FUNCION_ACTUAL);
return false;
}
//---
const uint16_t new_pos_idx = (uint16_t)ArraySize(m_positions);
ArrayResize(m_positions, new_pos_idx + 1);
m_positions[new_pos_idx] = p;
//---
if(!InsertHash(p.ticket, new_pos_idx))
{
ArrayResize(m_positions, new_pos_idx);
LogError(StringFormat("No se pudo insertar el ticket %I64u en la tabla hash", p.ticket), FUNCION_ACTUAL);
return false;
}
//---
// LogInfo(StringFormat("Añadiendo el ticket %I64u al array de posiciones >> tipo: %s >> profit: %+.2f", p.ticket, EnumToString(p.type), p.profit), FUNCION_ACTUAL);
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CTicketsInfo::DeleteByIndex(const int16_t pos_idx)
{
//---
if(pos_idx < 0)
{
LogError(StringFormat("Indice invalido %d", pos_idx), FUNCION_ACTUAL);
return false;
}
//---
const ulong ticket = m_positions[pos_idx].ticket;
if(!RemoveHash(ticket))
{
LogError(StringFormat("Fallo al eliminar el ticket %I64u de la tabla hash", ticket), FUNCION_ACTUAL);
return false;
}
//---
const int16_t last_idx = Total() - 1;
if(pos_idx != last_idx)
{
m_positions[pos_idx] = m_positions[last_idx];
UpdateHashAfterSwap(m_positions[pos_idx].ticket, pos_idx);
}
//---
ArrayResize(m_positions, last_idx);
return true;
}
//+------------------------------------------------------------------+
bool CTicketsInfo::DeleteByTicket(const ulong ticket)
{
//---
const int16_t pos_idx = FindHash(ticket);
if(pos_idx < 0)
{
LogError(StringFormat("No se pudo eliminar el ticket %I64u, ya que no existe", ticket), FUNCION_ACTUAL);
return false;
}
//---
if(!RemoveHash(ticket))
{
LogError(StringFormat("Fallo al eliminar el ticket %I64u de la tabla hash", ticket), FUNCION_ACTUAL);
return false;
}
//---
const int16_t last_idx = Total() - 1;
if(pos_idx != last_idx)
{
m_positions[pos_idx] = m_positions[last_idx];
UpdateHashAfterSwap(m_positions[pos_idx].ticket, pos_idx);
}
//---
ArrayResize(m_positions, last_idx);
return true;
}
//+------------------------------------------------------------------+
bool CTicketsInfo::DeleteByTicket(const ulong ticket, Position &position)
{
//---
const int16_t pos_idx = FindHash(ticket);
if(pos_idx < 0)
{
LogError(StringFormat("No se pudo eliminar el ticket %I64u, ya que no existe", ticket), FUNCION_ACTUAL);
return false;
}
//---
position = m_positions[pos_idx];
//---
if(!RemoveHash(ticket))
{
LogError(StringFormat("Fallo al eliminar el ticket %I64u de la tabla hash", ticket), FUNCION_ACTUAL);
return false;
}
//---
const int16_t last_idx = Total() - 1;
if(pos_idx != last_idx)
{
m_positions[pos_idx] = m_positions[last_idx];
UpdateHashAfterSwap(m_positions[pos_idx].ticket, pos_idx);
}
//---
ArrayResize(m_positions, last_idx);
return true;
}
//+------------------------------------------------------------------+
void CTicketsInfo::Free(void)
{
ArrayFree(m_positions);
m_hash_count = 0;
ArrayInitialize(m_hash_table, 65535);
ArrayInitialize(m_hash_filled, false);
}
//+------------------------------------------------------------------+
inline bool CTicketsInfo::Exists(const ulong ticket) const
{
return FindHash(ticket) >= 0;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
class CAccountGestor : public CAllClassEventsBasic
{
public:
CAccountGestor(const bool& is_g) : CAllClassEventsBasic(is_g) {}
~CAccountGestor() {}
//--- Positions
virtual void OnOpenClosePosition(const ROnOpenClosePosition &pos) {} //Function that will be executed each time a position is opened or closed
virtual void OnPositionModify(const Position& pos, const uint8_t change_flags) { }
//--- Orders
virtual void OnOrderAdd(const ROrder& order) { }
virtual void OnOrderUpdate(const ROrder& order) { }
virtual void OnOrderDelete(const ROrder& order) { }
//-- Function that is executed only once, where only the account profit fields are filled, such as account_gross_profit
//daily, weekly, etc.
virtual void OnNewProfit(const ROnOpenClosePosition &profit, const datetime& curr_time) { }
//--- Function that is executed each time TesterDeposit or TesterWithdrawal is called... or capital is added to the account
virtual void OnWithdrawalDeposit(const double& value) { } //If the value is positive it means a deposit, otherwise a withdrawal
//--- Function that is executed only once, only if there are previously open trades, only the position structure
virtual void OnInitNewPos(const ROnOpenClosePosition &position) { }
//---
virtual void OnLossProfit(const double& p) {}
};
//+------------------------------------------------------------------+
#endif // MQLARTICLES_RM_RFUNCTIONS_MQH
View git blameCopy permalink