BaseRangeAlgo

Files CCore/inc/algon/BaseRangeAlgo.h CCore/src/algon/BaseRangeAlgo.cpp

BaseRangeAlgo is an Algorithm Package. It is parametrized by a generalized range type and contains some simple range algorithms.

template <class R>
struct Algon::BaseRangeAlgo
 {
  using LenType = ??? ;
  
  static ??? GetPtr(R r); // GetLen(r)>0

  static LenType GetLen(R r);
  
  static R GetPrefix(R r,LenType len); // len <= GetLen(r)
   
  static R GetSuffix(R r,LenType len); // len <= GetLen(r)
  
  static R Split(R &r,LenType prefix); // prefix <= GetLen(r)
  
  static R GetPrefix(R r,R suffix); // suffix is an r suffix

  static void RangeSwap(R a,R b); // GetLen(a) == GetLen(b)

  static auto Reverse(R r);
 };

LenType is a range length type. It must be an unsigned integral type.

GetPtr() returns a "pointer" to the first range element. This pointer must be used only to reference this element and not to iterate over the range.

GetLen() returns the range length.

GetPrefix() returns a new range, which is a prefix of the given with the given length. len must not exceed the input range length.

GetSuffix() returns a new range, which is a suffix of the given with the given length. len must not exceed the input range length.

Split() splits the given range on prefix and suffix, prefix has a given length and returned, suffix is set back in the argument r. prefix must not exceed the input range length.

GetPrefix(R r,R suffix) returns the prefix, complementary to the given range suffix. It is equivalent to the GetPrefix(r,GetLen(r)-GetLen(suffix)).

RangeSwap() performs memberwise ranges element swap. Range lengths must be the same.

Reverse() returns a reverse range. Its type is different than R.

The following specialization for the standard PtrLen range is provided:

template <class T>
struct Algon::BaseRangeAlgo<PtrLen<T> >
 {
  using LenType = ulen ;
  
  static T * GetPtr(PtrLen<T> r) { return r.ptr; }

  static LenType GetLen(PtrLen<T> r) { return r.len; }
  
  static PtrLen<T> GetPrefix(PtrLen<T> r,LenType len) { return r.prefix(len); }
   
  static PtrLen<T> GetSuffix(PtrLen<T> r,LenType len) { return r.suffix(len); }
  
  static PtrLen<T> Split(PtrLen<T> &r,LenType prefix) { return r+=prefix; }
  
  static PtrLen<T> GetPrefix(PtrLen<T> r,PtrLen<T> suffix) { return r.prefix(suffix); }

  static void RangeSwap(PtrLen<T> a,PtrLen<T> b)
   {
    for(T *p=b.ptr; +a ;++a,++p) Swap(*a,*p); 
   }

  static PtrLenReverse<T> Reverse(PtrLen<T> r) { return RangeReverse(r); }
 };

The following specialization for the standard PtrLenReverse range is provided:

template <class T>
struct Algon::BaseRangeAlgo<PtrLenReverse<T> >
 {
  using LenType = ulen ;
  
  static T * GetPtr(PtrLenReverse<T> r) { return r.ptr-1; }
  
  static LenType GetLen(PtrLenReverse<T> r) { return r.len; }
  
  static PtrLenReverse<T> GetPrefix(PtrLenReverse<T> r,LenType len) { return r.prefix(len); }
   
  static PtrLenReverse<T> GetSuffix(PtrLenReverse<T> r,LenType len) { return r.suffix(len); }
  
  static PtrLenReverse<T> Split(PtrLenReverse<T> &r,LenType prefix) { return r+=prefix; }
  
  static PtrLenReverse<T> GetPrefix(PtrLenReverse<T> r,PtrLenReverse<T> suffix) { return r.prefix(suffix); }
  
  static void RangeSwap(PtrLenReverse<T> a,PtrLenReverse<T> b)
   {
    for(T *p=b.ptr; +a ;++a,--p) Swap(*a,p[-1]); 
   }

  static PtrLen<T> Reverse(PtrLenReverse<T> r) { return r.reverse(); }
 };