mql5/Include/Generic/SortedSet.mqh

//+------------------------------------------------------------------+
//|                                                   SortedList.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Generic\Interfaces\ISet.mqh>
#include <Generic\Internal\Introsort.mqh>
#include "RedBlackTree.mqh"
#include "HashSet.mqh"
//+------------------------------------------------------------------+
//| Class CSortedSet<T>.                                             |
//| Usage: Represents a collection of objects that is maintained in  |
//|        sorted order.                                             |
//+------------------------------------------------------------------+
template<typename T>
class CSortedSet: public ISet<T>
  {
protected:
   CRedBlackTree<T>*m_tree;

public:
                     CSortedSet(void);
                     CSortedSet(IComparer<T>*comparer);
                     CSortedSet(ICollection<T>*collection);
                     CSortedSet(ICollection<T>*collection,IComparer<T>*comparer);
                     CSortedSet(T &array[]);
                     CSortedSet(T &array[],IComparer<T>*comparer);
                    ~CSortedSet(void);
   //--- methods of filling data 
   bool              Add(T value) { return(m_tree.Add(value));     }
   //--- methods of access to protected data
   int               Count(void)          { return(m_tree.Count());        }
   bool              Contains(T item)     { return(m_tree.Contains(item)); }
   IComparer<T>     *Comparer(void) const { return(m_tree.Comparer());     }
   bool              TryGetMin(T &min)    { return(m_tree.TryGetMin(min)); }
   bool              TryGetMax(T &max)    { return(m_tree.TryGetMax(max)); }
   //--- methods of copy data from collection   
   int               CopyTo(T &dst_array[],const int dst_start=0);
   //--- methods of cleaning and deleting
   void              Clear(void)        { m_tree.Clear();              }
   bool              Remove(T item)     { return(m_tree.Remove(item)); }
   //--- methods of changing sets
   void              ExceptWith(ICollection<T>*collection);
   void              ExceptWith(T &array[]);
   void              IntersectWith(ICollection<T>*collection);
   void              IntersectWith(T &array[]);
   void              SymmetricExceptWith(ICollection<T>*collection);
   void              SymmetricExceptWith(T &array[]);
   void              UnionWith(ICollection<T>*collection);
   void              UnionWith(T &array[]);
   //--- methods for determining the relationship between sets
   bool              IsProperSubsetOf(ICollection<T>*collection);
   bool              IsProperSubsetOf(T &array[]);
   bool              IsProperSupersetOf(ICollection<T>*collection);
   bool              IsProperSupersetOf(T &array[]);
   bool              IsSubsetOf(ICollection<T>*collection);
   bool              IsSubsetOf(T &array[]);
   bool              IsSupersetOf(ICollection<T>*collection);
   bool              IsSupersetOf(T &array[]);
   bool              Overlaps(ICollection<T>*collection);
   bool              Overlaps(T &array[]);
   bool              SetEquals(ICollection<T>*collection);
   bool              SetEquals(T &array[]);
   //--- methods for working with an ordered set
   bool              GetViewBetween(T &array[],T lower_value,T upper_value);
   bool              GetReverse(T &array[]);
  };
//+------------------------------------------------------------------+
//| Initializes a new instance of the CSortedSet<T> class that is    |
//| empty and uses the default equality comparer for the set type.   |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::CSortedSet(void)
  {
   m_tree=new CRedBlackTree<T>();
  }
//+------------------------------------------------------------------+
//| Initializes a new instance of the CSortedSet<T> class that is    |
//| empty and uses the specified equality comparer for the set type. |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::CSortedSet(IComparer<T>*comparer)
  {
   m_tree=new CRedBlackTree<T>(comparer);
  }
//+------------------------------------------------------------------+
//| Initializes a new instance of the CSortedSet<T> class that uses  |
//| the default equality comparer for the set type, contains elements|
//| copied from the specified collection, and has sufficient capacity|
//| to accommodate the number of elements copied.                    |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::CSortedSet(ICollection<T>*collection)
  {
   m_tree=new CRedBlackTree<T>(collection);
  }
//+------------------------------------------------------------------+
//| Initializes a new instance of the CSortedSet<T> class that uses  |
//| the specified equality comparer for the set type, contains       |
//| elements copied from the specified collection, and has sufficient|
//| capacity to accommodate the number of elements copied.           |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::CSortedSet(ICollection<T>*collection,IComparer<T>*comparer)
  {
   m_tree=new CRedBlackTree<T>(collection,comparer);
  }
//+------------------------------------------------------------------+
//| Initializes a new instance of the CSortedSet<T> class that uses  |
//| the default equality comparer for the set type, contains         |
//| elements copied from the specified array, and has sufficient     |
//| capacity to accommodate the number of elements copied.           |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::CSortedSet(T &array[])
  {
   m_tree=new CRedBlackTree<T>(array);
  }
//+------------------------------------------------------------------+
//| Initializes a new instance of the CSortedSet<T> class that uses  |
//| the specified equality comparer for the set type, contains       |
//| elements copied from the specified array, and has sufficient     |
//| capacity to accommodate the number of elements copied.           |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::CSortedSet(T &array[],IComparer<T>*comparer)
  {
   m_tree=new CRedBlackTree<T>(array,comparer);
  }
//+------------------------------------------------------------------+
//| Destructor.                                                      |
//+------------------------------------------------------------------+
template<typename T>
CSortedSet::~CSortedSet(void)
  {
   delete m_tree;
  }
//+------------------------------------------------------------------+
//| Copies a range of elements from the set to a compatible          |
//| one-dimensional array.                                           |
//+------------------------------------------------------------------+
template<typename T>
int CSortedSet::CopyTo(T &dst_array[],const int dst_start=0)
  {
   return(m_tree.CopyTo(dst_array, dst_start));
  }
//+------------------------------------------------------------------+
//| Removes all elements in the specified collection from the current|
//| set.                                                             |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::ExceptWith(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return;
//--- check tree count
   if(m_tree.Count()==0)
      return;
//--- special case if collection is this
//--- a set minus itself is the empty set
   if(collection==GetPointer(this))
     {
      Clear();
      return;
     }
//--- copy collection to array
   T array[];
   int size=collection.CopyTo(array);
//--- find max and min value
   T max;
   T min;
//--- get comaprer
   IComparer<T>*comparer=Comparer();
   if(!m_tree.TryGetMax(max))
      return;
   if(!m_tree.TryGetMin(min))
      return;
//--- remove elements
   for(int i=0; i<size; i++)
     {
      T item=array[i];
      if(!(comparer.Compare(item,min)<0 || comparer.Compare(item,max)>0) && Contains(item))
         m_tree.Remove(item);
     }
  }
//+------------------------------------------------------------------+
//| Removes all elements in the specified array from the current set.|
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::ExceptWith(T &array[])
  {
//--- check tree count
   if(m_tree.Count()==0)
      return;
//--- get array size
   int size=ArraySize(array);
//--- find max and min value
   T max;
   T min;
//--- get comparer
   IComparer<T>*comparer=Comparer();
   if(!m_tree.TryGetMax(max))
      return;
   if(!m_tree.TryGetMin(min))
      return;
//--- remove elements   
   for(int i=0; i<size; i++)
     {
      T item=array[i];
      if(!(comparer.Compare(item,min)<0 || comparer.Compare(item,max)>0) && Contains(item))
         m_tree.Remove(item);
     }
  }
//+------------------------------------------------------------------+
//| Modifies the current set to contain only elements that are       |
//| present in that object and in the specified collection.          |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::IntersectWith(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return;
//--- check tree count
   if(m_tree.Count()==0)
      return;
//--- special case if collection is this
//--- a set minus itself is the empty set
   if(collection==GetPointer(this))
      return;
//--- copy collection to array
   T array[];
   int size=collection.CopyTo(array);
//--- create emty tree
   CRedBlackTree<T>*tree=new CRedBlackTree<T>();
//--- store values conatin in tree and array
   for(int i=0; i<size; i++)
      if(m_tree.Contains(array[i]))
         tree.Add(array[i]);
//--- overwrite tree
   delete m_tree;
   m_tree=tree;
  }
//+------------------------------------------------------------------+
//| Modifies the current set to contain only elements that are       |
//| present in that object and in the specified array.               |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::IntersectWith(T &array[])
  {
//--- check tree count
   if(m_tree.Count()==0)
      return;
//--- get array size
   int size=ArraySize(array);
//--- create emty tree
   CRedBlackTree<T>*tree=new CRedBlackTree<T>();
//--- store values conatin in tree and array
   for(int i=0; i<size; i++)
      if(m_tree.Contains(array[i]))
         tree.Add(array[i]);
//--- overwrite tree
   delete m_tree;
   m_tree=tree;
  }
//+------------------------------------------------------------------+
//| Modifies the current set to contain only elements that are       |
//| present either in that set or in the specified collection, but   |
//| not both.                                                        |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::SymmetricExceptWith(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return;
//--- check collection count
   if(collection.Count()==0)
      return;
//--- check tree count
   if(m_tree.Count()==0)
     {
      UnionWith(collection);
      return;
     }
//--- special case if collection is this
//--- a set minus itself is the empty set
   if(collection==GetPointer(this))
     {
      Clear();
      return;
     }
//--- copy colleaction to array
   T array[];
   int size=collection.CopyTo(array);
//--- get comparer
   IComparer<T>*comparer=m_tree.Comparer();
//--- sort array
   Introsort<T,T>sort;
   ArrayCopy(sort.keys,array);
   sort.comparer=comparer;
   sort.Sort(0, size);
   ArrayCopy(array,sort.keys);
//--- modify tree
   T last=array[0];
   for(int i=0; i<size; i++)
     {
      while(i<size && i!=0 && comparer.Compare(array[i],last)==0)
         i++;
      if(i>=size)
         break;

      if(m_tree.Contains(array[i]))
         m_tree.Remove(array[i]);
      else
         m_tree.Add(array[i]);

      last=array[i];
     }
  }
//+------------------------------------------------------------------+
//| Modifies the current set to contain only elements that are       |
//| present either in that set or in the specified array, but not    |
//| both.                                                            |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::SymmetricExceptWith(T &array[])
  {
//--- check array size
   if(ArraySize(array)==0)
      return;
//--- check tree count
   if(m_tree.Count()==0)
     {
      UnionWith(array);
      return;
     }
//--- get size
   int size=ArraySize(array);
//--- get comparer 
   IComparer<T>*comparer=m_tree.Comparer();
//--- sort array
   Introsort<T,T>sort;
   ArrayCopy(sort.keys,array);
   sort.comparer=comparer;
   sort.Sort(0, size);
   ArrayReverse(sort.keys,0,ArraySize(sort.keys));
//--- modify tree
   T last=sort.keys[0];
   for(int i=0; i<size; i++)
     {
      while(i<size && i!=0 && comparer.Compare(sort.keys[i],last)==0)
         i++;
      if(i>=size)
         break;

      if(m_tree.Contains(sort.keys[i]))
         m_tree.Remove(sort.keys[i]);
      else
         m_tree.Add(sort.keys[i]);

      last=sort.keys[i];
     }
  }
//+------------------------------------------------------------------+
//| Modifies the current set to contain all elements that are present|
//| in itself, the specified collection, or both.                    |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::UnionWith(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return;
//--- copy all elements from collecton to array
   T array[];
   int size=collection.CopyTo(array);
//--- add all elemets from array to set
   for(int i=0; i<size; i++)
      m_tree.Add(array[i]);
  }
//+------------------------------------------------------------------+
//| Modifies the current set to contain all elements that are present|
//| in itself, the specified array, or both.                         |
//+------------------------------------------------------------------+
template<typename T>
void CSortedSet::UnionWith(T &array[])
  {
//--- get array size
   int size=ArraySize(array);
//--- add all elemets from array to set
   for(int i=0; i<size; i++)
      m_tree.Add(array[i]);
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a proper subset of the specified     |
//| collection.                                                      |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsProperSubsetOf(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return(false);
//--- check tree count
   if(m_tree.Count()==0)
      return(collection.Count() > 0);
//--- check collection is set
   CHashSet<T>*ptr_set=dynamic_cast<CHashSet<T>*>(collection);
   if(CheckPointer(ptr_set)!=POINTER_INVALID)
     {
      return(ptr_set.IsProperSupersetOf(m_tree));
     }
   else
     {
      //--- create a set based on a specified collection
      CHashSet<T>set(collection);
      return(set.IsProperSupersetOf(m_tree));
     }
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a proper subset of the specified     |
//| array.                                                           |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsProperSubsetOf(T &array[])
  {
   if(m_tree.Count()==0)
      return(ArraySize(array) > 0);
//--- create a set based on a specified array
   CHashSet<T>set(array);
   if(m_tree.Count()>=set.Count())
      return(false);
   return(set.IsProperSupersetOf(m_tree));
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a proper superset of the specified   |
//| collection.                                                      |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsProperSupersetOf(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return(m_tree.Count()>0);
//--- check tree count
   if(m_tree.Count()==0)
      return(false);
//--- check collection count
   if(collection.Count()==0)
      return(true);
//--- check collection is set
   CHashSet<T>*ptr_set=dynamic_cast<CHashSet<T>*>(collection);
   if(CheckPointer(ptr_set)!=POINTER_INVALID)
     {
      return(ptr_set.IsProperSubsetOf(m_tree));
     }
   else
     {
      //--- create a set based on a specified collection
      CHashSet<T>set(collection);
      return(set.IsProperSubsetOf(m_tree));
     }
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a proper superset of the specified   |
//| array.                                                           |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsProperSupersetOf(T &array[])
  {
   if(m_tree.Count()==0)
      return(false);
   if(ArraySize(array)==0)
      return(true);
//--- create a set based on a specified array
   CHashSet<T>set(array);
   return(set.IsProperSubsetOf(m_tree));
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a subset of the specified collection.|
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsSubsetOf(ICollection<T>*collection)
  {
//--- cehck collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return(m_tree.Count()==0);
//--- check tree count
   if(m_tree.Count()==0)
      return(true);
//--- check collection is set
   CHashSet<T>*ptr_set=dynamic_cast<CHashSet<T>*>(collection);
   if(CheckPointer(ptr_set)==POINTER_DYNAMIC)
     {
      return(ptr_set.IsProperSupersetOf(m_tree));
     }
   else
     {
      //--- create a set based on a specified collection
      CHashSet<T>set(collection);
      return(set.IsProperSupersetOf(m_tree));
     }
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a subset of the specified array.     |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsSubsetOf(T &array[])
  {
//--- check tree count
   if(m_tree.Count()==0)
      return(true);
//--- create a set based on a specified array
   CHashSet<T>set(array);
   if(m_tree.Count()>set.Count())
      return(false);
   return(set.IsProperSupersetOf(m_tree));
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a superset of the specified          |
//| collection.                                                      |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsSupersetOf(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return(m_tree.Count()>=0);
//--- check collection count
   if(collection.Count()==0)
      return(true);
//--- check collection is set
   CHashSet<T>*ptr_set=dynamic_cast<CHashSet<T>*>(collection);
   if(CheckPointer(ptr_set)!=POINTER_INVALID)
     {
      return(ptr_set.IsSupersetOf(m_tree));
     }
   else
     {
      //--- create a set based on a specified collection
      CHashSet<T>set(collection);
      return(set.IsSupersetOf(m_tree));
     }
  }
//+------------------------------------------------------------------+
//| Determines whether a set is a superset of the specified array.   |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::IsSupersetOf(T &array[])
  {
//--- check array size
   if(ArraySize(array)==0)
      return(true);
//--- create a set based on a specified array
   CHashSet<T>set(array);
   return(set.IsSupersetOf(m_tree));
  }
//+------------------------------------------------------------------+
//| Determines whether the current set and a specified collection    |
//| share common elements.                                           |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::Overlaps(ICollection<T>*collection)
  {
//--- check collection
   if(CheckPointer(collection)==POINTER_INVALID)
      return(false);
//--- check tree count
   if(m_tree.Count()==0)
      return(false);
//--- check collection count
   if(collection.Count()==0)
      return(false);
//--- check collection is set
   CHashSet<T>*ptr_set=dynamic_cast<CHashSet<T>*>(collection);
   if(CheckPointer(ptr_set)!=POINTER_INVALID)
     {
      return(ptr_set.Overlaps(m_tree));
     }
   else
     {
      //--- create a set based on a specified collection
      CHashSet<T>set(collection);
      return(set.Overlaps(m_tree));
     }
  }
//+------------------------------------------------------------------+
//| Determines whether the current set and a specified array share   |
//| common elements.                                                 |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::Overlaps(T &array[])
  {
//--- check tree count
   if(m_tree.Count()==0)
      return(false);
//--- check array size
   if(ArraySize(array)==0)
      return(false);
//--- convert array to set
   CHashSet<T>set(array);
   return(set.Overlaps(m_tree));
  }
//+------------------------------------------------------------------+
//| Determines whether a set and the specified collection contain the|
//| same elements.                                                   |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::SetEquals(ICollection<T>*collection)
  {
   if(CheckPointer(collection)==POINTER_INVALID)
      return(false);
//--- get array from collection
   T array[];
   collection.CopyTo(array);
//--- check current set is equal specified array
   return SetEquals(array);
  }
//+------------------------------------------------------------------+
//| Determines whether a set and the specified array contain the same|
//| elements.                                                        |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::SetEquals(T &array[])
  {
//--- try find all elements in the tree
   for(int i=0; i<ArraySize(array); i++)
      if(!m_tree.Contains(array[i]))
         return(false);
   return(true);
  }
//+------------------------------------------------------------------+
//| Copy a view of a subset in a CSortedSet<T> to array.             |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::GetViewBetween(T &array[],T lower_value,T upper_value)
  {
//--- get comparer
   IComparer<T>*comparer=m_tree.Comparer();
   if(comparer.Compare(lower_value,upper_value)>0)
      return(false);
//--- copy all element from tree to array
   T buff[];
   int size=m_tree.CopyTo(buff);
//--- check range
   if(size==0 || comparer.Compare(buff[0],upper_value)>0 || comparer.Compare(buff[size-1],lower_value)<0)
      return(false);
//--- find first element greater than lower_value
   int index_lower=0;
   while(index_lower<size && comparer.Compare(buff[index_lower],lower_value)<0)
      index_lower++;
//--- find first element less than upper_value
   int index_upper=size-1;
   while(index_upper>0 && comparer.Compare(buff[index_upper],upper_value)>0)
      index_upper--;
//--- check indices
   if(index_lower>index_upper)
      return(false);
//--- copy view between lower_value and upper_value to array
   return(ArrayCopy(array,buff,0,index_lower,index_upper-index_lower+1)>=0);
  }
//+------------------------------------------------------------------+
//| Copy the CSortedSet<T> in reverse order to array.                |
//+------------------------------------------------------------------+
template<typename T>
bool CSortedSet::GetReverse(T &array[])
  {
   int size=m_tree.CopyTo(array);
   return ArrayReverse(array,0,size);
  }
//+------------------------------------------------------------------+