//+------------------------------------------------------------------+
//|                                                ArrayFunction.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include "CompareFunction.mqh"
#include <Generic\Interfaces\IComparer.mqh>
//+------------------------------------------------------------------+
//| Searches an entire one-dimensional sorted array for a specific   |
//| element, using the IComparable<T> generic interface implemented  |
//| by each element of the array and by the specified object.        |
//+------------------------------------------------------------------+
template<typename T>
int ArrayBinarySearch(T &array[],const int start_index,const int count, T value,IComparer<T>*comparer)
  {
   int lo=start_index;
   int hi=start_index+count-1;
   int size=ArraySize(array);
//--- check array size
   if(size==0)
      return(-1);
//--- check comaparer
   if(CheckPointer(comparer)==POINTER_INVALID)
      return(-1);
//--- check index
   if(start_index<0 || count<0 || size-start_index<count)
      return(-1);
//--- bianry search value   
   while(lo<=hi)
     {
      int i=lo+((hi-lo)>>1);
      int order=comparer.Compare(array[i],value);
      if(order==0)
        {
         return(i);
        }
      if(order<0)
        {
         lo=i+1;
        }
      else
        {
         hi=i-1;
        }
     }
//--- returns the index of an element nearest in value
   if(lo>0)
      return(lo-1);
   return(lo);
  }
//+------------------------------------------------------------------+
//| Searches for the specified object and returns the index of its   |
//| first occurrence in a one-dimensional array.                     |
//+------------------------------------------------------------------+
template<typename T>
int ArrayIndexOf(T &array[],T value,const int start_index,const int count)
  {
   int size=ArraySize(array);
//--- check array size
   if(size==0)
      return(-1);
//--- check start index and count
   if(start_index<0 || start_index>size || 
      count<0 || count>size-start_index)
      return(-1);
//--- search value
   int end_index=start_index+count;
   for(int i=start_index; i<end_index; i++)
     {
      //--- check the value in array is eqaul to specified value     
      if(::Equals(array[i],value))
        {
         //--- return fist index 
         return(i);
        }
     }
//--- return -1 if value not in array                                     
   return(-1);
  }
//+------------------------------------------------------------------+
//| Returns the index of the last occurrence of a value in a         |
//| one-dimensional array.                                           |
//+------------------------------------------------------------------+
template<typename T>
int ArrayLastIndexOf(T &array[],T value,const int start_index,const int count)
  {
   int size=ArraySize(array);
//--- check array size
   if(size==0)
      return(-1);
//--- check start index and count
   if(start_index<0 || start_index>=size || 
      count<0 || count>start_index+1)
      return(-1);
//--- search value
   int end_index=start_index-count+1;
   for(int i=start_index; i>=end_index; i--)
     {
      //--- check the value in array is eqaul to specified value     
      if(::Equals(array[i],value))
        {
         //--- return fist index from the end         
         return (i);
        }
     }
//--- return -1 if value not in array
   return(-1);
  }
//+------------------------------------------------------------------+
//| Reverses the elements in a range of this array. Following a call |
//| to this method, an element in the range given by index and count |
//| which was previously located at index i will now be located at   |
//| index index + (index + count - i - 1).                           |
//+------------------------------------------------------------------+
template<typename T>
bool ArrayReverse(T &array[],const int start_index,const int count)
  {
   int size=ArraySize(array);
//--- check start index and count
   if(count<0 || size-start_index<count)
      return(false);
//--- reverse elements
   int i = start_index;
   int j = start_index + count - 1;
   while(i<j)
     {
      T temp=array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   return(true);
  }
//+------------------------------------------------------------------+