Close All FIFO

ÿþ//+------------------------------------------------------------------+

//|                                               Close All FIFO.mq5 |

//|                              Copyright © 2021, Vladimir Karputov |

//|                     https://www.mql5.com/ru/market/product/43161 |

//+------------------------------------------------------------------+

#property copyright "Copyright © 2021, Vladimir Karputov"

#property link      "https://www.mql5.com/ru/market/product/43161"

#property version   "1.001"

//---

#include <Trade\PositionInfo.mqh>

#include <Trade\Trade.mqh>

//---

CPositionInfo  m_position;                   // object of CPositionInfo class

CTrade         m_trade;                      // object of CTrade class

//---

bool     m_need_close_all           = true;  // close all positions

bool     m_stop                     = false; // stop EA

ulong    m_tickets[];

//+------------------------------------------------------------------+

//|                                                    LineTable.mqh |

//|                        Copyright 2017, MetaQuotes Software Corp. |

//|                                              http://www.mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2017, MetaQuotes Software Corp."

#property link      "http://www.mql5.com"

#property version   "1.00"

#include <Object.mqh>

#include <Arrays\ArrayObj.mqh>

#define EQUAL 0

#define LESS -1

#define MORE 1

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

enum ENUM_SORT_TYPE

  {

   SORT_BY_TICKET,

   SORT_BY_TIME_MSC

  };

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

class CLineTable : public CObject

  {

private:

   ulong             m_ticket;            // position ticket

   ulong             m_time_msc;          // position time (msc)

public:

                     CLineTable();

                    ~CLineTable();

   //---

                     CLineTable(ulong ticket,ulong time_msc)

     {

      m_ticket=ticket;

      m_time_msc=time_msc;

     }

   ulong             Ticket()                               const { return m_ticket;   }

   ulong             TimeMsc()                              const { return m_time_msc; }

   virtual int       Compare(const CObject *node,const int mode=0) const

     {

      const CLineTable *line=node;

      switch(mode)

        {

         case SORT_BY_TICKET:

            if(line.Ticket()==this.Ticket())

               return EQUAL;

            else

               if(line.Ticket()<this.Ticket())

                  return MORE;

               else

                  return LESS;

         case SORT_BY_TIME_MSC:

            if(line.TimeMsc()==this.TimeMsc())

               return EQUAL;

            else

               if(line.TimeMsc()<this.TimeMsc())

                  return MORE;

               else

                  return LESS;

        }

      return EQUAL;

     }

  };

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

CLineTable::CLineTable()

  {

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

CLineTable::~CLineTable()

  {

  }

//+------------------------------------------------------------------+

//| Expert initialization function                                   |

//+------------------------------------------------------------------+

int OnInit()

  {

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| Expert deinitialization function                                 |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

  {

//---

  }

//+------------------------------------------------------------------+

//| Expert tick function                                             |

//+------------------------------------------------------------------+

void OnTick()

  {

   if(m_stop)

      return;

//---

   if(m_need_close_all)

     {

      if(IsPositionExists())

        {

         CloseAllPositions();

         return;

        }

      else

        {

         m_need_close_all=false;

         m_stop=true;

        }

     }

  }

//+------------------------------------------------------------------+

//| Close all positions                                              |

//+------------------------------------------------------------------+

void CloseAllPositions(void)

  {

   int size=ArraySize(m_tickets);

   if(size==0) // first start

     {

      CArrayObj Table;

      Table.Sort(SORT_BY_TIME_MSC);

      for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions

         if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

            Table.InsertSort(new CLineTable(m_position.Ticket(),m_position.TimeMsc()));

      //--- l

      for(int i=0; i<Table.Total(); i++)

        {

         CLineTable *line=Table.At(i);

         size=ArraySize(m_tickets);

         ArrayResize(m_tickets,size+1);

         m_tickets[size]=line.Ticket();

        }

      //---

      ArraySetAsSeries(m_tickets,true);

     }

   else

     {

      for(int i=size-1; i>=0; i--)

         if(m_position.SelectByTicket(m_tickets[i])) // selects the position by index for further access to its properties

            if(!m_trade.PositionClose(m_position.Ticket())) // close a position

               Print(__FILE__," ",__FUNCTION__,", ERROR: ","PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());

     }

  }

//+------------------------------------------------------------------+

//| Is position exists                                               |

//+------------------------------------------------------------------+

bool IsPositionExists(void)

  {

   for(int i=PositionsTotal()-1; i>=0; i--)

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

         return(true);

//---

   return(false);

  }

//+------------------------------------------------------------------+