//+------------------------------------------------------------------+ //| Base.mqh | //| Copyright 2025, Niquel Mendoza. | //| https://www.mql5.com/es/users/nique_372/news | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, Niquel Mendoza." #property link "https://www.mql5.com/es/users/nique_372/news" #property strict #ifndef MQLARTICLES_POSMGMT_CONDPARTIALS_BASE_BASE_MQH #define MQLARTICLES_POSMGMT_CONDPARTIALS_BASE_BASE_MQH //+------------------------------------------------------------------+ //| Include | //+------------------------------------------------------------------+ #include "Defines.mqh" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ namespace TSN { //+------------------------------------------------------------------+ //| Base class for conditional partials implementation | //+------------------------------------------------------------------+ class CConditionalPartials : public CAccountGestor { protected: //--- General IConditionPartial* m_partial_condition; // Pointer to IConditionPartial, this pointer will give the condition to close buy and sell positions partially bool m_delete_partial_condition_in_dstctor; CTrade m_trade; // CTrade instance, to apply partial closes int m_tries; // Number of tryes //--- Tracked Positions // Array of ConditionalPartialTrackedPosition type, this array will store the positions // To which partial closes will be applied ConditionalPartialTrackedPosition m_tracked_positions_arr[]; int m_tracked_positions_size; // Number of positions being tracked int m_tracked_positions_r; bool m_tracked_positions_remove[]; // Parallel to m_tracked_positions_arr (same size): true = remove, always false between calls // Volume double m_volumes_to_close_arr[]; // Array of percentages, that will close the trades in m_tracked_positions_arr int m_volume_to_close_size; // Number of partial closes planned for each trade // Centinela: // m_constant_partials=0 entonces valdra m_volume_to_close_size // m_constant_partials=MQLART_CONDPARTIAL_CONSTANT entonces valdra 0 // La idea con esto es en caso sea constante no hace falta revisar si "se supero el numero de indices" por lo qeu idx=1 == 0 (siempre falso) // De lo contraio si hace falta.. por lo que se revisa.. // Con constant partials solo se usa el (indice 0 y se "repite" para siempre... como volumebn vs usar un array que en cada parcial se cierra X..) // Nota que por defecto No es constante.. aparte si es contaste: next_index_to_close ya no se usa o peirde el significaod () int m_centinela; //--- Symbol string m_symbol; // Symbol from which data like min_volume, step, etc. will be obtained double m_symbol_bid; // Symbol bid double m_symbol_ask; // Symbol ask double m_symbol_min_volume; // Minimum volume (opening or closing) for symbol m_symbol double m_symbol_volume_step; // Volume step for symbol m_symbol int8_t m_symbol_digits; // Digits of symbol "m_symbol" //--- Parameters // Boolean that will indicate to the class if when trades are opened (with the magic number, or magic number = 0), they will be added // Automatically to the trackable positions array bool m_auto_add_to_tracked_positions; TsnUniquePtr(CDiff) m_unique_m_min_distance_to_close_pos; CDiff* m_min_distance_to_close_pos; // Pointer to CDiff, this will give the minimum distance between partial closes ulong m_magic_number; // Magic number bool m_forze_to_close; // Forze close total position double m_min_distance_value; // Minimum distance between partials (value) char m_constant_partials; // Partials is constant (only zero idx) ? //--- Symbol Functions void RefreshSymbolData(); //--- Partials closures Functions template void ClosePartial(); public: CConditionalPartials(); ~CConditionalPartials(); //--- Initialization function bool Init(ConditionalPartialConfig& config); //--- Add function virtual void AddPositionToTrack(ENUM_POSITION_TYPE position_type, ulong position_ticket, double open_price); bool AddPositionToTrack(ulong position_ticket); //--- Remove bool RemoveTrackedPosition(ulong position_ticket); //--- Events functions void OnOpenPosition(const ROnOpenPosition &pos) override final; void OnClosePosition(const ROnClosePosition &pos, const int global_pos_index) override final; //--- Execute function void Execute(const datetime& current_time); // OnNewBar //--- Config // Condition IConditionPartial* PartialCloseCondition() { return m_partial_condition; } void PartialCloseCondition(IConditionPartial* new_condition, bool delete_prev_ptr); // Magic number ulong MagicNumber() const { return m_magic_number; } void MagicNumber(ulong new_value); // Minimum distance between partial closures CDiff* MinDistBetweenPartialClosures() { return m_min_distance_to_close_pos; } void MinDistBetweenPartialClosures(CDiff* new_value); // Symbol string Symbol() { return m_symbol; } void Symbol(string new_symbol); // Auto mode bool IsAutoMode() const { return m_auto_add_to_tracked_positions; } void AutoMode(bool new_value) { m_auto_add_to_tracked_positions = new_value; } // Tryes int Tries() const { return m_tries; } void Tries(int v) { m_tries = v; } // Force to close bool ForzeToClose() const { return m_forze_to_close; } void ForzeToClose(bool new_val) { m_forze_to_close = new_val; } // Constant bool Constant() const { return m_constant_partials == MQLART_CONDPARTIAL_CONSTANT; } void Constant(bool new_val); //--- Tracked positions size int TrackedPositionsSize() const { return m_tracked_positions_size; } //--- Errores static void FormatTrace(const TSNErrorFrame &trace[], int &trace_idx, string &out); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CConditionalPartials::CConditionalPartials() : //--- m_partial_condition(NULL), m_symbol(NULL), m_symbol_ask(0.00), m_symbol_bid(0.00), m_symbol_digits(0), m_symbol_min_volume(0.00), m_symbol_volume_step(0.00), m_auto_add_to_tracked_positions(true), m_min_distance_to_close_pos(NULL), m_magic_number(NOT_MAGIC_NUMBER), m_volume_to_close_size(0), m_min_distance_value(0.00), m_delete_partial_condition_in_dstctor(true), m_forze_to_close(false), m_centinela(0), //--- m_tracked_positions_r(CONDITIONAL_PARTIAL_ARR_MAIN_RESERVE), m_tracked_positions_size(0), m_tries(MQLART_POSMGMT_CONDPARTIALS_TRYDEF) { //--- account_status.RegisterEvents(&this, ACCOUNT_STATUS_REG_FLAG_ON_OPEN_POSITION | ACCOUNT_STATUS_REG_FLAG_ON_CLOSE_POSITION); //--- ::ArrayResize(m_tracked_positions_arr, CONDITIONAL_PARTIAL_ARR_MAIN_RESERVE, CONDITIONAL_PARTIAL_ARR_MAIN_RESERVE); ::ArrayResize(m_tracked_positions_remove, CONDITIONAL_PARTIAL_ARR_MAIN_RESERVE, CONDITIONAL_PARTIAL_ARR_MAIN_RESERVE); ::ArrayInitialize(m_tracked_positions_remove, false); } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CConditionalPartials::~CConditionalPartials() { //--- Delete of event pool if(account_status.IsActive()) account_status.UnregisterEvents(&this, ACCOUNT_STATUS_REG_FLAG_ON_OPEN_POSITION | ACCOUNT_STATUS_REG_FLAG_ON_CLOSE_POSITION); //--- Delete condition if(m_delete_partial_condition_in_dstctor && CheckPointer(m_partial_condition) == POINTER_DYNAMIC) delete m_partial_condition; } //+------------------------------------------------------------------+ //| Initialization function, the function sets the class parameters | //| through the "config" variable. | //| Inputs: | //| - ConditionalPartialConfig& config: variable that will store the | //| initial class configuration. | //| Outputs: | //| - bool: The function returns true on success, otherwise false. | //+------------------------------------------------------------------+ bool CConditionalPartials::Init(ConditionalPartialConfig& config) { //--- Assignment m_magic_number = config.magic_number; m_symbol = config.symbol; m_auto_add_to_tracked_positions = config.auto_mode; if(m_magic_number != NOT_MAGIC_NUMBER) m_trade.SetExpertMagicNumber(m_magic_number); // Min distance m_unique_m_min_distance_to_close_pos.Reset(config.min_distance_to_close_pos); m_min_distance_to_close_pos = m_unique_m_min_distance_to_close_pos.m_value; // Partial condition m_partial_condition = config.condition; m_delete_partial_condition_in_dstctor = config.delete_condition; // Extra m_forze_to_close = config.forze_to_close; //--- Symbol refresh RefreshSymbolData(); //--- m_volume_to_close_size = CStringFunc::ToArr( config.str_percentage_volume_to_close, m_volumes_to_close_arr, ','); if(m_volume_to_close_size < 1) { if(m_volume_to_close_size == 0) // string vacio return CErrorTrace::FailInit(TSNQMLART_CONDPARTIAL_ERR_INVALID_NUM_VOLTOCLOSE_ARR, 0); // < 0: valor mal formado, ToArr devuelve la posicion return CErrorTrace::FailInit(TSNQMLART_CONDPARTIAL_ERR_MALFORMED_VOLTOCLOSE, ulong(TSNSTD_STRFUNC_TOARR_REQPOS(m_volume_to_close_size))); } //--- for(int i = 0; i < m_volume_to_close_size; i++) { const double val = m_volumes_to_close_arr[i]; if(val > 100.0 || val < 0.00001) { return CErrorTrace::FailInit(TSNQMLART_CONDPARTIAL_ERR_INVALID_VOLTOCLOSE_MUSTBE_0_100, CBitsReinterprete::ToBasic(val)); } m_volumes_to_close_arr[i] /= 100.00; } //--- Constant(config.constant); //--- Print array #ifdef CONDITIONAL_PARTIAL_MORE_INFO ArrayPrint(m_volumes_to_close_arr, 2, " | ", 0, m_volume_to_close_size); #endif // CONDITIONAL_PARTIAL_MORE_INFO //--- Finish return true; } //+-------------------------------------------------------------------------------------------+ //| Function that executes the main logic of the class | //| Inputs: | //| datetime current_time: Variable of datetime type, which must | //| store the current time. | //| Outputs: the function returns nothing. | //| Notes: | //| - The function can be called on each tick or each bar, this | //| will depend on the Execute function of the m_partial_condition variable, | //| for example if the condition is an indicator, like RSI | //| the logic could be executed on each candle, or for example if the condition | //| evaluates a mitigation of an orderblock, in this case it would be executed on each tick | //| | //| - The define "CONDITIONAL_PARTIAL_EXECUTE_WHEN_THE_ARE_POSITIONS", | //| allows conditional code compilation, if this define is defined | //| the Execute(..) function of the m_partial_condition pointer, will only be called | //| when there are open positions, otherwise if the define is not defined | //| it will be called at all times. | //+-------------------------------------------------------------------------------------------+ //#define CONDITIONAL_PARTIAL_EXECUTE_WHEN_THE_ARE_POSITIONS //+------------------------------------------------------------------+ void CConditionalPartials::Execute(const datetime& current_time) { #ifdef CONDITIONAL_PARTIAL_EXECUTE_WHEN_THE_ARE_POSITIONS if(m_tracked_positions_size > 0) { //--- Execution m_partial_condition.Execute(current_time); //--- Close conditions const bool buy = m_partial_condition.CloseBuy(); const bool sell = m_partial_condition.CloseSell(); //--- Obtain min diff if(buy || sell) { m_min_distance_to_close_pos.OnNewBar(); m_min_distance_value = m_min_distance_to_close_pos.Diff(); //--- Check buy condition if(buy) { m_symbol_bid = ::SymbolInfoDouble(m_symbol, SYMBOL_BID); ClosePartial(); } //--- Check sell condition if(sell) { m_symbol_ask = ::SymbolInfoDouble(m_symbol, SYMBOL_ASK); ClosePartial(); } } } #else //--- Execution m_partial_condition.Execute(current_time); //--- Check conditions if(m_tracked_positions_size > 0) { //--- Close conditions const bool buy = m_partial_condition.CloseBuy(); const bool sell = m_partial_condition.CloseSell(); //--- Obtain min diff if(buy || sell) { m_min_distance_to_close_pos.OnNewBar(); m_min_distance_value = m_min_distance_to_close_pos.Diff(); //--- Check buy condition if(buy) { m_symbol_bid = ::SymbolInfoDouble(m_symbol, SYMBOL_BID); ClosePartial(); } //--- Check sell condition if(sell) { m_symbol_ask = ::SymbolInfoDouble(m_symbol, SYMBOL_ASK); ClosePartial(); } } } #endif } //+------------------------------------------------------------------+ //| Function that executes every time a trade is closed or opened | //+------------------------------------------------------------------+ void CConditionalPartials::OnOpenPosition(const ROnOpenPosition &pos) { if((pos.position.magic == m_magic_number || m_magic_number == NOT_MAGIC_NUMBER) && account_status.last_trans_symbol == m_symbol) { #ifdef CONDITIONAL_PARTIAL_MORE_INFO FastLog(FUNCION_ACTUAL, INFO_TEXT, ::StringFormat("A trade has just been opened with ticket %I64u", pos.position.ticket), FUNCION_ACTUAL); #endif // CONDITIONAL_PARTIAL_MORE_INFO AddPositionToTrack(pos.position.type, pos.position.ticket, pos.position.open_price); } } //+------------------------------------------------------------------+ void CConditionalPartials::OnClosePosition(const ROnClosePosition &pos, const int global_pos_index) { // Once the position is closed we verify if that ticket is in the internal array, if so the function // will remove it. RemoveTrackedPosition(pos.position.ticket); } //+-------------------------------------------------------------------------+ //| The function creates a new trackable position and adds it | //| to the internal array. | //| Inputs: | //| - ENUM_POSITION_TYPE position_type: position type (buy or sell) | //| - ulong position_ticket: Position ticket. | //| - double open_price: Trade opening price. | //| Outputs: The function returns no value. | //| Notes: | //| - The position ticket must be valid, | //| the function will not check if the ticket exists. | //+-------------------------------------------------------------------------+ void CConditionalPartials::AddPositionToTrack(ENUM_POSITION_TYPE position_type, ulong position_ticket, double open_price) { //--- if(m_tracked_positions_size == 0) // First position to be added to the tracked positions array m_partial_condition.OnInitPartials(open_price); //--- Obtain current value m_min_distance_to_close_pos.OnNewBar(); m_min_distance_value = m_min_distance_to_close_pos.Diff(); //--- if(m_tracked_positions_size >= m_tracked_positions_r) { const int old_r = m_tracked_positions_r; m_tracked_positions_r <<= 1; ArrayResize(m_tracked_positions_arr, m_tracked_positions_r, m_tracked_positions_r); ArrayResize(m_tracked_positions_remove, m_tracked_positions_r, m_tracked_positions_r); for(int i = old_r; i < m_tracked_positions_r; i++) // Iniciamos la cola nueva m_tracked_positions_remove[i] = false; } //--- Creation of a new position to track m_tracked_positions_arr[m_tracked_positions_size].try = m_tries; m_tracked_positions_arr[m_tracked_positions_size].type = position_type; m_tracked_positions_arr[m_tracked_positions_size].ticket = position_ticket; m_tracked_positions_arr[m_tracked_positions_size].next_min_price = position_type == POSITION_TYPE_BUY ? open_price + m_min_distance_value : open_price - m_min_distance_value; m_tracked_positions_arr[m_tracked_positions_size].next_index_to_close = 0; //--- m_tracked_positions_size++; } //+-------------------------------------------------------------------------+ //| With a function similar to the AddPositionToTrack(...) function | //| differing in that this overloaded function only requires the | //| position ticket (the function internally already queries the | //| position type, open_price, etc.). | //| Inputs: | //| - ulong position_ticket: Position ticket. | //| Outputs: Returns true if a trackable position could be created with the | //| ticket, otherwise false | //| Notes: | //| - If the position ticket doesn't exist, or is invalid (failure of | //| PositionSelectByTicket) the function will not create a new trackable | //| position with the ticket | //+-------------------------------------------------------------------------+ bool CConditionalPartials::AddPositionToTrack(ulong position_ticket) { //--- ::ResetLastError(); //--- Select if(!::PositionSelectByTicket(position_ticket)) { return CErrorTrace::FailInit(TSNQMLART_CONDPARTIAL_ERR_SELECT_POSITION, position_ticket, ::GetLastError()); } //--- Check symbol if(::PositionGetString(POSITION_SYMBOL) != m_symbol) { return CErrorTrace::FailInit(TSNQMLART_CONDPARTIAL_ERR_INVALID_SYMBOL, position_ticket); } //--- Add AddPositionToTrack((ENUM_POSITION_TYPE)::PositionGetInteger(POSITION_TYPE), position_ticket, ::PositionGetDouble(POSITION_PRICE_OPEN)); return true; } //+------------------------------------------------------------------+ //| Function that iterates over all positions to track (buy) | //| and partially closes the trade | //+------------------------------------------------------------------+ template void CConditionalPartials::ClosePartial(void) { //--- opt: solo un booleano como fastpath para eliminar o no (las marcas viven en m_tracked_positions_remove) bool already_remove = false; //--- #define CONDITIONAL_PARTIAL_REMOVEPOS(IDX) m_tracked_positions_remove[IDX] = true; already_remove = true; //--- Iteration for(int i = 0; i < m_tracked_positions_size; i++) { //--- if(m_tracked_positions_arr[i].type != (sizeof(TPositionType) - 1) || ((sizeof(TPositionType) == sizeof(MQLART_CONDPARTIAL_PBUY)) ? (m_symbol_bid < m_tracked_positions_arr[i].next_min_price) : (m_symbol_ask > m_tracked_positions_arr[i].next_min_price))) continue; //--- if(!::PositionSelectByTicket(m_tracked_positions_arr[i].ticket)) { #ifdef CONDITIONAL_PARTIAL_MORE_INFO FastLog(FUNCION_ACTUAL, ERROR_TEXT, ::StringFormat("Ticket selection failed %I64u", m_tracked_positions_arr[i].ticket)); #endif // CONDITIONAL_PARTIAL_MORE_INFO //--- CONDITIONAL_PARTIAL_REMOVEPOS(i) continue; } //--- int idx = m_tracked_positions_arr[i].next_index_to_close++ >> m_constant_partials; //--- Initial calculation const double lot_size =::PositionGetDouble(POSITION_VOLUME); double volume_to_close = m_volumes_to_close_arr[idx++] * lot_size; //--- Check min volume to close if(volume_to_close < m_symbol_min_volume) { if(m_forze_to_close) volume_to_close = lot_size; else { #ifdef CONDITIONAL_PARTIAL_MORE_INFO FastLog(FUNCION_ACTUAL, WARNING_TEXT, ::StringFormat("Partial close of position %I64u skipped, volume to close %.*f is less than minimum volume %.*f", m_tracked_positions_arr[i].ticket, m_symbol_digits, volume_to_close, m_symbol_digits, m_symbol_min_volume)); #endif // CONDITIONAL_PARTIAL_MORE_INFO //--- CONDITIONAL_PARTIAL_REMOVEPOS(i) continue; } } //--- Round volume_to_close = MQLART_POSMGMT_CONDPARTIALS_LOTROUND(volume_to_close, m_symbol_volume_step); //--- Close if(!m_trade.PositionClosePartial(m_tracked_positions_arr[i].ticket, volume_to_close)) { //--- #ifdef CONDITIONAL_PARTIAL_MORE_INFO FastLog(FUNCION_ACTUAL, INFO_TEXT, ::StringFormat("Fallo al cerrar parcialem,nte = %.2f lotes de la posicion = %I64u", volume_to_close, m_tracked_positions_arr[i].ticket)); #endif // CONDITIONAL_PARTIAL_MORE_INFO //--- m_tracked_positions_arr[i].next_index_to_close--; // rollback if(--m_tracked_positions_arr[i].try < 0) { CONDITIONAL_PARTIAL_REMOVEPOS(i) } continue; } //--- #ifdef CONDITIONAL_PARTIAL_MORE_INFO FastLog(FUNCION_ACTUAL, INFO_TEXT, ::StringFormat("Partially closing %.2f lots of position %I64u", volume_to_close, m_tracked_positions_arr[i].ticket)); #endif // CONDITIONAL_PARTIAL_MORE_INFO //--- m_tracked_positions_arr[i].next_min_price += m_min_distance_value; //--- Check limit if(idx == m_centinela) // Limit reached { CONDITIONAL_PARTIAL_REMOVEPOS(i) } } //--- Check para eliminar if(!already_remove) return; //--- Eliminamos int w = 0; for(int r = 0; r < m_tracked_positions_size; r++) { if(!m_tracked_positions_remove[r]) { if(w != r) m_tracked_positions_arr[w] = m_tracked_positions_arr[r]; w++; } else m_tracked_positions_remove[r] = false; } m_tracked_positions_size = w; // opt: solo cambiamos el tamaƱo "virtual" //--- #undef CONDITIONAL_PARTIAL_REMOVEPOS } //+----------------------------------------------------------------------------------+ //| The function sets a new partial close "condition", it changes | //| the "address" of the m_partial_condition pointer to new_condition, and | //| if necessary the previous pointer is deleted | //| Inputs: | //| - IConditionPartial *new_condition: Pointer to IConditionPartial. | //| - bool delete_prev_ptr: Boolean indicating if the internal pointer is deleted | //| Outputs: The function returns nothing. | //+----------------------------------------------------------------------------------+ void CConditionalPartials::PartialCloseCondition(IConditionPartial *new_condition, bool delete_prev_ptr) { //--- Delete prev ptr if(delete_prev_ptr && ::CheckPointer(m_partial_condition) == POINTER_DYNAMIC) { delete m_partial_condition; } //--- m_partial_condition = new_condition; } //+------------------------------------------------------------------+ //| Sets a new internal pointer for the minimum distance | //| between partials. | //| Inputs: | //| - CDiff *new_value: Pointer to CDiff. | //| Outputs: The function returns no value | //+------------------------------------------------------------------+ void CConditionalPartials::MinDistBetweenPartialClosures(CDiff *new_value) { //--- m_unique_m_min_distance_to_close_pos.Reset(new_value); m_min_distance_to_close_pos = new_value; } //+------------------------------------------------------------------+ //| Sets a new value for the magic number | //| Inputs: | //| - ulong new_value: new magic number value. | //| Outputs: The function returns no value | //+------------------------------------------------------------------+ void CConditionalPartials::MagicNumber(ulong new_value) { m_magic_number = new_value; m_trade.SetExpertMagicNumber(new_value); } //+------------------------------------------------------------------+ //| Sets a new symbol. | //| Inputs: | //| - string new_symbol: New symbol. | //| Outputs: The function returns no value. | //| Notes: | //| - The function should only be called when there are no | //| open positions, to avoid unexpected bugs with | //| tracked positions from other symbols. | //+------------------------------------------------------------------+ void CConditionalPartials::Symbol(string new_symbol) { m_symbol = new_symbol; RefreshSymbolData(); } //+------------------------------------------------------------------+ //| Removes a trackable position from the internal array | //| Inputs: | //| ulong position_ticket: Ticket of the trackable position to be | //| removed | //| Outputs: The function returns true, if the ticket was | //| successfully removed, otherwise false (ticket does not | //| exist). | //+------------------------------------------------------------------+ bool CConditionalPartials::RemoveTrackedPosition(ulong position_ticket) { //--- int index = -1; for(int i = 0; i < m_tracked_positions_size; i++) { if(m_tracked_positions_arr[i].ticket == position_ticket) { index = i; break; } } //--- if(index == -1) { return CErrorTrace::FailInit(TSNQMLART_CONDPARTIAL_ERR_POSITION_NOT_FOUND, position_ticket); } //--- if(index != --m_tracked_positions_size) m_tracked_positions_arr[index] = m_tracked_positions_arr[m_tracked_positions_size]; //--- return true; // Success } //+------------------------------------------------------------------+ //| "Re-queries" the values of minimum volume, volume step and | //| symbol digits. | //+------------------------------------------------------------------+ void CConditionalPartials::RefreshSymbolData(void) { m_symbol_digits = (int8_t)::SymbolInfoInteger(m_symbol, SYMBOL_DIGITS); m_symbol_min_volume = ::SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MIN); m_symbol_volume_step = ::SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_STEP); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CConditionalPartials::Constant(bool new_val) { m_constant_partials = MQLART_CONDPARTIAL_CONSTANT * new_val; m_centinela = new_val * m_volume_to_close_size; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ static void CConditionalPartials::FormatTrace(const TSNErrorFrame &trace[], int &trace_idx, string &out) { TSNSTD_ERRMAN_PUSHINI(out, trace_idx) switch(trace[trace_idx].code) { case TSNQMLART_CONDPARTIAL_ERR_NOT: TSNSTD_ERRMAN_PUSHOUT(out, "Not errors", trace_idx) break; case TSNQMLART_CONDPARTIAL_ERR_INVALID_NUM_VOLTOCLOSE_ARR: TSNSTD_ERRMAN_PUSHOUT(out, "It was not possible to obtain at least one volume from the provided string representing the array of volumes to be closed.", trace_idx) break; case TSNQMLART_CONDPARTIAL_ERR_MALFORMED_VOLTOCLOSE: TSNSTD_ERRMAN_PUSHOUT(out, StringFormat("Malformed double found in the string-comma-separated volumes to close, expected position in the array = [%d]", int(trace[trace_idx].info)), trace_idx) break; case TSNQMLART_CONDPARTIAL_ERR_INVALID_VOLTOCLOSE_MUSTBE_0_100: TSNSTD_ERRMAN_PUSHOUT(out, StringFormat("The percentage of volume to be closed [%.4f] must be greater than 0.0 and less than or equal to 100.0.", CBitsReinterprete::ToBasic(trace[trace_idx].info)), trace_idx) break; case TSNQMLART_CONDPARTIAL_ERR_SELECT_POSITION: TSNSTD_ERRMAN_PUSHOUT(out, StringFormat("Error in select position [ticket = %I64u] last err = %d", trace[trace_idx].info, trace[trace_idx].mql_err), trace_idx) break; case TSNQMLART_CONDPARTIAL_ERR_INVALID_SYMBOL: TSNSTD_ERRMAN_PUSHOUT(out, StringFormat("Invalid symbol [ticket = %I64u] (must ve equal at CConditionalPartials::Symbol())", trace[trace_idx].info), trace_idx) break; case TSNQMLART_CONDPARTIAL_ERR_POSITION_NOT_FOUND: TSNSTD_ERRMAN_PUSHOUT(out, StringFormat("Position not found [ticket = %I64u]", trace[trace_idx].info), trace_idx) break; default: TSNSTD_ERRMAN_PUSHOUT(out, "Unknow error", trace_idx) break; } } //--- } #endif // MQLARTICLES_POSMGMT_CONDPARTIALS_BASE_BASE_MQH //+------------------------------------------------------------------+