ah-dry.H

/* Aleph-w

     / \  | | ___ _ __ | |__      __      __
    / _ \ | |/ _ \ '_ \| '_ \ ____\ \ /\ / / Data structures & Algorithms
   / ___ \| |  __/ |_) | | | |_____\ V  V /  version 1.9b
  /_/   \_\_|\___| .__/|_| |_|      \_/\_/   https://github.com/lrleon/Aleph-w
                 |_|         

  This file is part of Aleph-w library

  Copyright (c) 2002-2018 Leandro Rabindranath Leon & Alejandro Mujica

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program. If not, see <https://www.gnu.org/licenses/>.
*/

# ifndef AH_DRY_H
# define AH_DRY_H

# include "ahFunctional.H"

template <class Container>
struct GenericTraverse
{
  template <class Operation>
  bool traverse(Operation & operation) noexcept(noexcept(operation))
  {
    for (typename Container::Iterator it(*static_cast<Container*>(this));
         it.has_curr(); it.next_ne())
      if (not operation(it.get_curr_ne()))
        return false;
    return true;
  }

  template <class Operation>
  bool traverse(Operation & operation) const noexcept(noexcept(operation))
  {
    return const_cast<GenericTraverse*>(this)->traverse<Operation>(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation) const noexcept(noexcept(operation))
  {
    return traverse<Operation>(operation);
  }

  template <class Operation>
  bool traverse(Operation && operation) noexcept(noexcept(operation))
  {
    return traverse<Operation>(operation);
  }
};

template <class Container, class Operation>
bool traverse(const Container & c, Operation & op)
{
  return c.traverse(op);
}

template <class Container, class Operation>
bool traverse(const Container & c, Operation && op = Operation())
{
  return traverse<Container, Operation>(c, op);
}

template <class Container, typename Type>
class LocateFunctions
{
  Container * me() noexcept { return static_cast<Container*>(this); }

  const Container * const_me() const noexcept
  {
    return static_cast<const Container*>(this);
  }

  LocateFunctions<Container, Type> * base() const
  {
    return const_cast<LocateFunctions*>(this);
  }

public:

  auto get_it() const
  {
    auto ret = typename Container::Iterator(*const_me());
    return ret;
  }

  auto get_it(size_t pos) const
  {
    auto ret = typename Container::Iterator(*const_me());
    for (size_t i = 0; i < pos; ++i)
      ret.next();
    return ret;
  }

  auto get_itor() const { return get_it(); }

  Type & nth_ne(const size_t n) noexcept
  {
    Type * ptr = nullptr;
    size_t i = 0;
    me()->traverse([&ptr, &i, &n] (Type & item)
                   {
                     if (i++ < n)
                       return true;
                     ptr = &item;
                     return false;
                   });
    return *ptr;
  }

  const Type & nth_ne(const size_t n) const noexcept
  {
    return base()->nth_ne(n);
  }

  Type & nth(const size_t n)
  {
    Type * ptr = nullptr;
    size_t i = 0;
    me()->traverse([&ptr, &i, &n] (Type & item)
                   {
                     if (i++ < n)
                       return true;
                     ptr = &item;
                     return false;
                   });

    if (i != n + 1)
      throw std::out_of_range("index out of range");

    return *ptr;
  }

  const Type & nth(const size_t n) const
  {
    return base()->nth(n);
  }

  template <class Operation>
  Type * find_ptr(Operation & operation) noexcept(noexcept(operation))
  {
    Type * ptr = nullptr;
    me()->traverse([&ptr,&operation] (Type & item)
                   {
                     if (operation(item))
                       {
                         ptr = &item;
                         return false;
                       }
                     return true;
                   });
    return ptr;
  }

  template <class Operation>
  const Type * find_ptr(Operation & operation) const
    noexcept(noexcept(operation))
  {
    return base()->find_ptr(operation);
  }

  template <class Operation>
  const Type * find_ptr(Operation && operation) const
    noexcept(noexcept(operation))
  {
    return find_ptr<Operation>(operation);
  }

  template <class Operation>
  Type * find_ptr(Operation && operation) noexcept(noexcept(operation))
  {
    return find_ptr(operation);
  }

  template <class Operation>
  size_t find_index(Operation & operation) const noexcept(noexcept(operation))
  {
    size_t i = 0;
    const_me()->traverse([&i,&operation] (Type & item)
                         {
                           if (operation(item))
                             return false;
                           ++i;
                           return true;
                         });
    return i;
  }

  template <class Operation>
  size_t find_index(Operation && operation) const noexcept(noexcept(operation))
  {
    return find_index<Operation>(operation);
  }

  template <class Operation>
  std::tuple<bool, Type> find_item(Operation & operation)
    noexcept(noexcept(operation))
  {
    using TT = std::tuple<bool, Type>;
    auto ptr = find_ptr(operation);
    return ptr ? TT(true, *ptr) : TT(false, Type());
  }

  template <class Operation>
  std::tuple<bool, Type> find_item(Operation & operation) const
    noexcept(noexcept(operation))
  {
    using TT = std::tuple<bool, Type>;
    auto ptr = find_ptr(operation);
    return ptr ? TT(true, *ptr) : TT(false, Type());
  }

  template <class Operation>
  std::tuple<bool, Type> find_item(Operation && operation)
    noexcept(noexcept(operation))
  {
    return find_item(operation);
  }

  template <class Operation>
  std::tuple<bool, Type> find_item(Operation && operation) const
    noexcept(noexcept(operation))
  {
    return find_item(operation);
  }
};

template <class Container, typename T>
struct SpecialCtors
{
  SpecialCtors() {}

  SpecialCtors(const SpecialCtors&) {}

  SpecialCtors(SpecialCtors&&) {}

  SpecialCtors & operator = (const SpecialCtors&) { return *this; }

  SpecialCtors & operator = (SpecialCtors&&) { return *this; }

  SpecialCtors(const DynList<T> & l)
  {
    l.for_each([this] (const T & item)
               {
                 static_cast<Container*>(this)->append(item);
               });
  }

  template <class It>
  SpecialCtors(It b, It e)
  {
    for (It it = b; it != e; ++it)
      static_cast<Container*>(this)->append(*it);
  }

  SpecialCtors(std::initializer_list<T> l)
  {
    for (const auto & item : l)
      static_cast<Container*>(this)->append(item);
  }
};


template <class Container, typename T>
class FunctionalMethods
{
  Container * me() { return static_cast<Container*>(this); }

  FunctionalMethods<Container, T> * base() const noexcept
  {
    return const_cast<FunctionalMethods<Container, T>*>(this);
  }

  const Container * const_me() const noexcept
  {
    return static_cast<const Container*>(this);
  }

public:

  template <typename ...Args>
  void emplace(Args && ... args)
  {
    me()->append(T(args...));
  }

  template <typename ...Args>
  void emplace_end(Args && ... args)
  {
    me()->append(T(args...));
  }

  template <typename ...Args>
  void emplace_ins(Args && ... args)
  {
    me()->insert(T(args...));
  }

private:

  void nninsert(size_t&) {}
  void nnappend(size_t&) {}

  template <typename ... Args>
  void nninsert(size_t & n, const T & item, Args & ... args)
  {
    me()->insert(item);
    ++n;
    nninsert(n, args...);
  }

  template <typename ... Args>
  void nnappend(size_t & n, const T & item, Args & ... args)
  {
    me()->append(item);
    ++n;
    nnappend(n, args...);
  }

public:

  template <typename ... Args>
  size_t ninsert(Args ... args)
  {
    size_t n = 0;
    nninsert(n, args...);
    return n;
  }

  template <typename ... Args>
  size_t nappend(Args ... args)
  {
    size_t n = 0;
    nnappend(n, args...);
    return n;
  }

  template <class Operation>
  void for_each(Operation & operation) noexcept(noexcept(operation))
  {
    me()->traverse([&operation] (const T & item)
                   {
                     operation(item);
                     return true;
                   });
  }

  template <class Operation>
  void for_each(Operation & operation) const noexcept(noexcept(operation))
  {
    base()->for_each(operation);
  }

  template <class Operation>
  void for_each(Operation && operation) const noexcept(noexcept(operation))
  {
    for_each(operation);
  }

  template <class Operation>
  void for_each(Operation && operation) noexcept(noexcept(operation))
  {
    for_each(operation);
  }

  template <class Operation>
  void each(Operation & operation) noexcept(noexcept(operation))
  {
    for_each(operation);
  }

  template <class Operation>
  void each(Operation & operation) const noexcept(noexcept(operation))
  {
    for_each(operation);
  }

  template <class Operation>
  void each(Operation && operation) const noexcept(noexcept(operation))
  {
    for_each(operation);
  }

  template <class Operation>
  void each(Operation && operation) noexcept(noexcept(operation))
  {
    for_each(operation);
  }

  template <class Operation>
  void each(size_t pos, size_t slice, Operation & operation) const
  {
    auto it = const_me()->get_it(pos);
    for (size_t i = pos; true; i += slice)
      {
        operation(it.get_curr());
        for (size_t k = 0; k < slice; ++k)
          {
            it.next();
            if (not it.has_curr())
              return;
          }
      }
  }

  template <class Operation>
  void each(size_t pos, size_t slice, Operation && operation) const
  {
    each(pos, slice, operation);
  }

  template <class Operation>
  void mutable_for_each(Operation & operation) noexcept(noexcept(operation))
  {
    me()->traverse([&operation] (T & item)
                   {
                     operation(item);
                     return true;
                   });
  }

  template <class Operation>
  void mutable_for_each(Operation && operation) noexcept(noexcept(operation))
  {
    mutable_for_each(operation);
  }

  template <class Operation>
  bool all(Operation & operation) const noexcept(noexcept(operation))
  {
    return const_me()->traverse(operation);
  }

  template <class Operation>
  bool all(Operation && operation) const noexcept(noexcept(operation))
  {
    return all(operation);
  }

  template <class Operation>
  bool exists(Operation & op) const noexcept(noexcept(op))
  {
    return not const_me()->
      traverse([&op] (const T & i) { return not op(i); });
  }

  template <class Operation>
  bool exists(Operation && op) const noexcept(noexcept(op))
  {
    return exists(op);
  }

  template <typename __T = T, class Operation = Dft_Map_Op<T, __T>>
  DynList<__T> maps(Operation & op) const
  {
    DynList<__T> ret_val;
    const_me()->for_each([&ret_val, &op] (const T & item)
                         {
                           ret_val.append(op(item));
                         });
    return ret_val;
  }

  template <typename __T = T, class Operation = Dft_Map_Op<__T, __T>>
  DynList<__T> maps(Operation && op) const { return maps<__T, Operation>(op); }

  template <typename __T = T, class Prop, class Operation>
  DynList<__T> maps_if(Prop prop, Operation & op) const
  {
    DynList<__T> ret_val;
    const_me()->for_each([&ret_val, &prop, &op] (const T & item)
                         {
                           if (prop(item))
                             ret_val.append(op(item));
                         });
    return ret_val;
  }

  template <typename __T = T, class Prop, class Operation>
  DynList<__T> maps_if(Prop prop, Operation && op) const
  {
    return maps<__T, Prop, Operation>(prop, op);
  }

  DynList<T> to_dynlist() const
  {
    return maps([] (auto & item) { return item; });
  }

  template <typename __T = T, class Op = Dft_Fold_Op<__T, T>>
  __T foldl(const __T & init, Op & op) const noexcept(noexcept(op))
  {
    __T ret_val = init;
    const_me()->for_each([&ret_val, &op] (const T & item)
                         {
                           ret_val = op(ret_val, item);
                         });
    return ret_val;
  }

  template <typename __T = T, class Op = Dft_Fold_Op<__T, T>>
    __T foldl(const __T & init, Op && op = Op()) const noexcept(noexcept(op))
  {
    return foldl(init, op);
  }

  template <class Operation>
  T fold(const T & init, Operation & operation) const
    noexcept(noexcept(operation))
  {
    auto ret_val = init;
    const_me()->for_each([&ret_val, &operation] (const T & item)
                         {
                           ret_val = operation(ret_val, item);
                         });
    return ret_val;
  }

  template <class Operation>
  T fold(const T & init, Operation && operation) const
    noexcept(noexcept(operation))
  {
    return fold(init, operation);
  }

  template <class Operation>
  DynList<T> filter(Operation & operation) const
  {
    DynList<T> ret_val;
    const_me()->for_each([&ret_val, &operation] (const T & item)
                         {
                           if (operation(item))
                             ret_val.append(item);
                         });
    return ret_val;
  }

  template <class Operation>
  DynList<T> filter(Operation && operation) const
  {
    return filter(operation);
  }

  template <class Operation>
  DynList<const T*> ptr_filter(Operation & operation) const
  {
    DynList<const T*> ret_val;
    const_me()->for_each([&ret_val, &operation] (const T & item)
                         {
                           if (operation(item))
                             ret_val.append(&item);
                         });
    return ret_val;
  }

  template <class Operation>
  DynList<const T*> ptr_filter(Operation && operation) const
  {
    return ptr_filter(operation);
  }

  template <class Operation>
  DynList<std::tuple<T, size_t>> pfilter(Operation & operation) const
  {
    using TT = std::tuple<T, size_t>;
    DynList<TT> ret_val;
    size_t i = 0;
    const_me()->for_each([&ret_val, &operation, &i] (const T & item)
                         {
                           if (operation(item))
                             ret_val.append(TT(item, i));
                           ++i;
                         });
    return ret_val;
  }

  template <class Operation>
  DynList<std::tuple<T, size_t>> pfilter(Operation && operation) const
  {
    return pfilter(operation);
  }

  template <class Operation>
  std::pair<DynList<T>, DynList<T>> partition(Operation & op) const
  {
    std::pair<DynList<T>, DynList<T>> ret_val;
    const_me()->for_each([&ret_val, &op] (const T & item)
                         {
                           if (op(item))
                             ret_val.first.append(item);
                           else
                             ret_val.second.append(item);
                         });
    return ret_val;
  }

  template <class Operation>
  std::pair<DynList<T>, DynList<T>> partition(Operation && op) const
  {
    return partition(op);
  }

  template <class Operation>
  std::pair<DynList<T>, DynList<T>> partition(size_t n) const
  {
    size_t i = 0;
    std::pair<DynList<T>, DynList<T>> ret_val;
    const_me()->for_each([&ret_val, &i, n] (const T & item)
                         {
                           if (i++ < n)
                             ret_val.first.append(item);
                           else
                             ret_val.second.append(item);
                         });
    return ret_val;
  }

  template <class Operation>
  std::tuple<DynList<T>, DynList<T>> tpartition(Operation & op) const
  {
    DynList<T> r1, r2;
    const_me()->for_each([&r1, &r2, &op] (const T & item)
                         {
                           if (op(item))
                             r1.append(item);
                           else
                             r2.append(item);
                         });
    return std::tuple<DynList<T>, DynList<T>>(r1, r2);
  }

  template <class Operation>
  std::tuple<DynList<T>, DynList<T>> tpartition(Operation && op) const
  {
    return partition(op);
  }

  size_t length() const noexcept
  {
    size_t count = 0;
    const_me()->for_each([&count] (const T &) { ++count; });
    return count;
  }

  DynList<T> rev() const
  {
    DynList<T> ret;
    const_me()->for_each([&ret] (const T & i) { ret.insert(i); });
    return ret;
  }

  DynList<T> take(const size_t n) const
  {
    size_t i = 0;
    DynList<T> ret;
    const_me()->traverse([&i, &ret, n] (const T & item)
                         {
                           if (i++ >= n)
                             return false;
                           ret.append(item);
                           return true;
                         });
    return ret;
  }

  DynList<T> take(size_t i, size_t j, size_t step = 1) const
  {
    DynList<T> ret;
    if (step == 0)
      return ret;
    for (auto it = const_me()->get_it(i); i <= j and it.has_curr();
         it.next_ne(), i += step)
      ret.append(it.get_curr_ne());
    return ret;
  }

  DynList<T> drop(const size_t n) const
  {
    size_t i = 0;
    DynList<T> ret;
    const_me()->traverse([&i, &ret, n] (const T & item)
                         {
                           if (i++ >= n)
                             ret.append(item);
                           return true;
                         });
    return ret;
  }

  void mutable_drop(size_t n)
  {
    for (size_t i = 0; i < n; ++i)
      me()->remove();
  }
};

template <class Container, typename T>
struct GenericItems
{
  DynList<T> items() const
  {
    return static_cast<const Container*>(this)->
      Container::template maps<T> ([] (const T & key) { return key; });
  }

  DynList<T> keys() const { return items(); }
};


template <class Container, typename T>
using GenericKeys = GenericItems<Container, T>;


template <class Container>
class EqualToMethod
{
  const Container * const_me() const
  {
    return static_cast<const Container*>(this);
  }

public:

  bool equal_to(const Container & r) const noexcept
  {
    if (this == &r)
      return true;

    if (const_me()->size() != r.size())
      return false;

    return const_me()->all([&r] (const typename Container::Key_Type & k)
                           { return r.search(k) != nullptr; });
  }

  bool operator == (const Container & r) const  noexcept
  {
    return equal_to(r);
  }

  bool operator != (const Container & r) const  noexcept
  {
    return not equal_to(r);
  }
};

template <class Container, typename Key, typename Data>
class MapSequencesMethods
{
  const Container * const_me() const
  {
    return static_cast<const Container*>(this);
  }

public:

  template <template <typename> class C = DynList>
  C<Key> keys() const
  {
    C<Key> ret_val;
    const_me()->for_each([&ret_val] (const Key & p)
                         {
                           ret_val.append(p.first);
                         });
    return ret_val;
  }

  template <template <typename> class C = DynList>
  C<Data> values() const
  {
    C<Data> ret_val;
    const_me()->for_each([&ret_val] (const std::pair<Key, Data> & p)
                         {
                           ret_val.append(p.second);
                         });
    return ret_val;
  }

  template <template <typename> class C = DynList>
  C<Data*> values_ptr() const
  {
    C<Data*> ret_val;
    const_me()->for_each([&ret_val] (std::pair<Key, Data> & p)
                         { ret_val.append(&p.second); });
    return ret_val;
  }

  template <template <typename> class C = DynList>
  C<std::pair<Key, Data>> items() const
  {
    C<std::pair<Key, Data>> ret;
    const_me()->for_each([&ret] (std::pair<Key, Data> & p) { ret.append(p); });
    return ret;
  }

  template <template <typename> class C = DynList>
  C<std::pair<Key, Data*>> items_ptr() const
  {
    C<Data> ret_val;
    const_me()->for_each([&ret_val] (std::pair<Key, Data> & p)
                         {
                           ret_val.append(std::pair<Key,Data*>(p.first,
                                                               p.second));
                         });
    return ret_val;
  }

  Data & operator () (const Key & key)
  {
    return this->find(key);
  }

  const Data & operator () (const Key & key) const
  {
    return this->find(key);
  }
};



# endif // AH_DRY_H