Object List - library for MetaTrader 5

/****************************************************************
Object List
The List class template provides a basic container for storing an ordered list of objects.
For convenience, List also provides synonyms for stack operations,
 which make code that uses List for stacks more explicit without defining another class.
/**/

/****************************************************************/
template<typename T>class ObjectList
  {
public:
   //construction, destruction, initialization, and assignment
                     ObjectList(bool memdelete=true):mdelete(memdelete) {}
                     ObjectList(ObjectList&src) {mdelete=src.mdelete; Copy(items,src.items); Copy(mem,src.mem);}
                    ~ObjectList() {RemoveAll(); if(mdelete) EmptyMem();}
   ObjectList        operator=(ObjectList&);
   void              MemDelete(bool memdelete) {mdelete=memdelete;}
   //accessing
   T*                operator[](int i) {return Get(i);}
   T*                Get(int at) {int c=Count(); if(c>0&&at>=0&&at<c) {return items[at];} return NULL;}
   T*                First() {int c=Count(); if(c>0) {return items[0];} return NULL;}
   T*                Last() {int c=Count(); if(c>0) {return items[c-1];} return NULL;}
   bool              TryGet(T*dst,int at) {if((dst=Get(at))!=NULL) {return true;} else {return false;}}
   //
   int               Count() {KillBad(); return ArraySize(items);}
   int               Find(T*item) {int c=Count(); for(int i=0; i<c; i++) {if(item==items[i]) {return i;}} return -1;}
   void              PrintHash() {for(int i=0; i<ArraySize(items); i++) {PrintFormat("%d:%d(%s)",i,Hash(items[i]),typename(items[i]));}}
   int               Hash(T*item) {string s; StringConcatenate(s,s,item); return (int)StringToInteger(s);}
   int               Hash(int at) {T*p=Get(at); return (p!=NULL)?Hash(p):0;}
   //adding
   void              operator+=(T*item) {Append(item);}
   void              operator^=(T*item) {Prepend(item);}
   void              Append(T*item) {Append(item,items);}
   void              Prepend(T*item) {IncreaseAt(0); items[0]=item;}
   //removing
   void              operator-=(T*item) {Remove(item,0);}
   void              operator/=(T*item) {Remove(item,1);}
   void              operator~() {RemoveAll();}
   void              Remove(T*item,bool del=0) {int f=Find(item); if(f>-1) {{if(del) {Delete(item);} else {Append(item,mem);}} ReduceAt(f);}}
   void              RemoveLast(bool del=0) {KillBad(); if(del) {Delete(Last());} else {Append(Last(),mem);} ReduceAt(ArraySize(items)-1);}
   void              RemoveFirst(bool del=0) {KillBad(); if(del) {Delete(First());} else {Append(First(),mem);} ReduceAt(0);}
   void              RemoveAll(bool del=0);
   //stack interface
   T*                Top() {return Last();}
   void              Push(T*item) {Append(item);}
   T*                Pop() {T*top=Top(); RemoveLast(); return top;}
protected:
   T*                items[];
   T*                mem[];
   bool              mdelete;
   //service
   void              Append(T*item,T*&dst[]) {int r=ArrayResize(dst,ArraySize(dst)+1); dst[r-1]=item;}
   void              EmptyMem() {for(int i=0; i<ArraySize(mem); i++) {Delete(mem[i]);} ArrayFree(mem);}
   void              Delete(T*item) {if(CheckPointer(item)==1)delete item;}
   void              KillBad() {for(int i=0; i<ArraySize(items); i++) {if(items[i]==NULL) {ReduceAt(i); i--;}}}
   void              ReduceAt(int);
   void              IncreaseAt(int);
   void              Copy(T*&dst[],T*&src[]) {int c=ArraySize(src); ArrayResize(dst,c); for(int i=0; i<c; i++) {dst[i]=src[i];}}
  };
/**/

/****************************************************************
Structural notes
   By default, when the list is destroyed, it deletes all dynamic objects.
      Automatic objects will be destroyed anyway.
      This means that you do not have to use operator delete on any objects that you create.
      Once the object has been added to the list, it will not forget it,
       and be able to access it for erasing on destruction.
      Anything that is removed from the list, is transferred to the recycle bin,
       and kept there for safety, keeping the 'hanging' pointers,
       and thus minimizing the chance for the 'bad pointer access' critical error.
      This is justified in most cases, because computer memory is huge these days.
      There is not much burden on efficiency either, only memory, slight though.
      However, for flexibility, the Remove methods have the option to permanently delete the removed object.
      If you need to keep the objects after the list destruction (rare),
       use the MemDelete method to set the memdelete flag false.
      The 'del' parameter in Remove methods is a flag for deleting the object from memory.
      Access to the object will no longer be available, and will raise a critical error.
   The list keeps references to valid objects only, null pointers are removed on access/count attempt.
      However if you use access methods with pointer return, and try to access wrong index,
       you will get a null pointer, this means error index.
      There is a classic workaround for this: the TryGet method which writes the pointer and tells you
       if the returned pointer is valid, so if the method returns false, you shall not use the pointer.
   Hash methods return Mql internal object 'hash codes', as seen when you try to print an object/pointer.
      I'm not sure how these codes are generated, but they seem to be pretty reliable in identifying objects with ==.
Available operators:
   [index] Get,            eg. Class T* pointer=list[3];
   += Append,              eg. list+=pointer;   //list+=&object;
   ^= Prepend,             eg. list^=pointer;   //list+=&object;
   -= Remove,              eg. list-=pointer;   //list+=&object;
   /= Remove & delete,     eg. list/=pointer;   //list+=&object;
   ~ RemoveAll,            eg. ~list;
   = Copy list,            eg. Class listA=listB; //A-new,B-existing
/**/

/****************************************************************
Example of ObjectList usage
/****************************************************************/
void OnStart()
  {
   ObjectList<A>list;
   A* o1=new B();             //dynamic
   A  o2;                     //automatic
   A* o3=&o2;                 //automatic
   /**/
   list+=&o2;                 //append object ref
   list^=o1;                  //prepend
   list+=o3;                  //append pointer
   list.PrintHash();          //see output
   /**/
     {string s; for(int i=0; i<13; i++) {s+="-";} Print(s);}
   /**/
   list-=&o2;                 //remove
   ObjectList<A>list2=list;   //copy list
   list2.PrintHash();         //see output
   /**/
     {string s; for(int i=0; i<13; i++) {s+="-";} Print(s);}
   /**/
   ~list;                     //clean list, this is empty now
   list2.RemoveLast();        //remove
   list2.PrintHash();         //see output
   /**/
     {string s; for(int i=0; i<13; i++) {s+="-";} Print(s);}
   /**/
   A* o=list2[0];                                        //direct access
   Print(list2.Hash(o));   //2097152     //   same...    //risky to use o without check, but if you sure
   Print(list2.Hash(0));   //2097152     //...object
   Print(list2.TryGet(o,666)); //false, don't use o      //safe access
   /**
   ...On destruction the list will delete the dynamic object o1 from memory.
   /**/
  }
/****************************************************************
Output:
/**
   0:2097152(A*)
   1:3145728(A*)
   2:3145728(A*)
   -------------
   0:2097152(A*)
   1:3145728(A*)
   -------------
   0:2097152(A*)
   -------------
   2097152
   2097152
   false
/**/