ranges.h

//  Copyright 2021 Herald Project Contributors
//  SPDX-License-Identifier: Apache-2.0
//
 
#ifndef HERALD_RANGES_H
#define HERALD_RANGES_H
 
// TODO if def for C++20 support check (so we don't have to roll our own ranges lib)
// i.e. map std::views on to herald::analysis::views, otherwise include the following.
 
 
#include <array>
#include <map>
#include <variant>
#include <vector>
#include <cstdint>
#include <type_traits>
 
#include "sampling.h"
#include "../datatype/date.h"
 
namespace herald {
namespace analysis {
namespace views {
 
// Note: The following are SAMPLE filters, and only work with Samples
struct since {
  since(herald::datatype::Date after) : from(after) {}
  ~since() = default;
 
  template <typename ValT>
  bool operator()(const herald::analysis::sampling::Sample<ValT>& s) const {
    return s.taken > from;
  }
 
private:
  herald::datatype::Date from;
};
 
// Note: The following are value filters, and work with Samples and any other type
 
template <typename Pred1,typename Pred2>
struct dual_filter {
  dual_filter(const Pred1 p1, const Pred2 p2) : pred1(p1), pred2(p2) {}
  ~dual_filter() = default;
 
  template <typename VTOther>
  bool operator()(const VTOther& value) const {
    return pred1(value) && pred2(value);
  }
 
private:
  const Pred1 pred1;
  const Pred2 pred2;
};
 
// Is genericised to...
template <typename VT>
struct in_range {
  in_range(const VT min, const VT max) : min(min), max(max) {}
  ~in_range() = default;
 
  template <typename VTOther>
  bool operator()(const VTOther& value) const {
    return value >= min && value <= max;
  }
 
private:
  const VT min;
  const VT max;
};
 
template <typename VT>
struct greater_than {
  greater_than(const VT min) : min(min) {}
  ~greater_than() = default;
 
  template <typename VTOther>
  bool operator()(const VTOther& value) const {
    return value > min;
  }
 
private:
  const VT min;
};
 
template <typename VT>
struct less_than {
  less_than(const VT max) : max(max) {}
  ~less_than() = default;
 
  template <typename VTOther>
  bool operator()(const VTOther& value) const {
    return value < max;
  }
 
private:
  const VT max;
};
 
// TODO consider clamping modifications as well as in_range filtering
 
template <typename Coll,
          //typename ValT = typename std::remove_cv<typename Coll::value_type::first_type>::type,
          typename ValT = typename std::remove_cv<typename Coll::value_type>::type, // works for intrinsic types and complex types
          typename IterT = typename Coll::iterator,
          typename SizeT = typename Coll::size_type
         >
struct iterator_proxy {
  using base_iterator = IterT;
  using base_value_type = ValT;
  using base_size_type = SizeT;
 
  iterator_proxy(Coll& coll) : coll(coll), iter(std::move(std::begin(coll))), endIter(std::move(std::end(coll))) {}
  iterator_proxy(iterator_proxy&& other) : coll(other.coll), iter(std::move(other.iter)), endIter(std::move(other.endIter)) {}
  iterator_proxy(const iterator_proxy& other) : coll(other.coll), iter(other.iter), endIter(other.endIter) {}
  ~iterator_proxy() = default;
 
  auto operator*() -> const ValT& {
    return *iter;
  }
 
  iterator_proxy<Coll>& operator++() {
    ++iter;
    return *this; // reference to instance
  }
 
  // postfix operator
  iterator_proxy<Coll> operator++(int) {
    iterator_proxy<Coll> cp =  *this; // copy of instance
    ++(*this);
    return cp;
  }
 
  bool operator==(IterT otherIter) const {
    return iter == otherIter;
  }
 
  bool operator!=(IterT otherIter) const {
    return iter != otherIter;
  }
 
  friend bool operator!=(IterT otherIter,iterator_proxy<Coll> thisIter) {
    return otherIter != thisIter.iter;
  }
 
  friend bool operator==(IterT otherIter,iterator_proxy<Coll> thisIter) {
    return otherIter == thisIter.iter;
  }
 
  IterT& wrapped() {
    return iter;
  }
 
  IterT& end() {
    return endIter;
  }
 
  bool ended() {
    return endIter == iter;
  }
 
  Coll& collection() const {
    return coll;
  }
 
private:
  Coll& coll;
  IterT iter;
  IterT endIter;
};
 
template <typename Pred>
struct filter_fn {
  filter_fn(const Pred pred) : pred(pred) {}
  ~filter_fn() = default;
 
  template <typename ValT>
  auto operator()(const ValT& val) -> bool {
    return pred(val);
  }
 
  const Pred predicate() const {
    return pred;
  }
 
private:
  const Pred pred;
};
 
template <typename IterProxyT,
          typename BaseValT = typename IterProxyT::base_value_type,
          typename BaseIterT = typename IterProxyT::base_iterator,
          typename BaseSizeT = typename IterProxyT::base_size_type>
struct view {
  // Make this look like an STL collection (so filter<Coll,Pred> works with a view)
  using value_type = BaseValT;
  using iterator = BaseIterT;
  using size_type = BaseSizeT;
 
  using is_proxy = std::true_type;
 
  view(IterProxyT srcIter) : source(std::forward<IterProxyT>(srcIter)) {} // TAKE OWNERSHIP
  ~view() = default;
 
  auto begin() -> IterProxyT {
    return source;
  }
 
  auto end() -> BaseIterT {
    return source.end();
  }
 
  // auto latest() -> BaseValT {
  //   //return source.latest();
  //   return *(source.end() - 1);
  // }
  Date latest() {
    return (*(source.end() - 1)).taken;
  }
 
  template <typename IterT>
  bool operator==(const IterT& other) {
    return other == source;
  }
 
  template <typename IterT>
  bool operator!=(const IterT& other) {
    return other != source;
  }
 
  auto size() -> BaseSizeT {
    // return source.size(); // this is the UNFILTERED size
    BaseSizeT sz = 0;
    auto iter = source; // copy the iterator so as not to alter its state
    auto end = source.end(); // copy the iterator so as not to alter its state
    while (iter != end) {
      ++sz;
      ++iter;
    }
    // minus one as we don't want the distance to end() but the last element the 1 before it
    return sz;
    // return std::distance(source.wrapped(),source.end() - 1);
  }
 
  auto operator[](BaseSizeT position) -> BaseValT {
    return *(source + position);
  }
 
private:
  IterProxyT source;
};
 
template <typename Coll,
          typename Pred,
          // typename ValT = typename std::remove_cv<typename Coll::value_type::first_type>::type,
          typename ValT = typename std::remove_cv<typename Coll::value_type>::type, // works for intrinsic types and complex types
          typename IterT = typename Coll::iterator,
          typename SizeT = typename Coll::size_type
         >
struct filtered_iterator_proxy {
  using base_iterator = IterT;
  using base_coll_type = Coll; // for chaining
  using base_pred_type = Pred; // for chaining
  using base_value_type = ValT;
  using base_size_type = SizeT;
 
  using value_type = ValT;
  using iterator = IterT;
  using size_type = SizeT;
  // using difference_type = typename Coll::difference_type;
 
  using is_proxy = std::true_type;
 
  filtered_iterator_proxy(Coll& coll, Pred pred) : coll(coll), iter(std::move(std::begin(coll))), endIter(std::move(std::end(coll))), filter(pred) {
    // move forward to the first match (or end)
    moveToFirst();
  }
 
  // chaining ctor
  // filtered_iterator_proxy(filtered_iterator_proxy&& other, Pred pred) : iter(std::move(other.iter)), endIter(std::move(other.endIter)), filter(dual_filter(other.filter,pred)) {}
  filtered_iterator_proxy(filtered_iterator_proxy&& other) : coll(other.coll), iter(std::move(other.iter)), endIter(std::move(other.endIter)), filter(other.filter) {}
  filtered_iterator_proxy(const filtered_iterator_proxy& other) : coll(other.coll), iter(other.iter), endIter(other.endIter), filter(other.filter) {}
  ~filtered_iterator_proxy() = default;
 
  auto operator*() -> const ValT& {
    return *iter;
  }
 
  filtered_iterator_proxy<Coll,Pred>& operator++() {
    // move forward until we get a match (or end)
    moveToNext();
    return *this;
  }
 
  // postfix operator
  filtered_iterator_proxy<Coll,Pred> operator++(int) {
    filtered_iterator_proxy<Coll,Pred> cp =  *this; // copy of instance
    ++(*this);
    return cp;
  }
 
  filtered_iterator_proxy<Coll,Pred> operator+(int by) {
    filtered_iterator_proxy<Coll,Pred> cp =  *this; // copy of instance
    for (int i = 0;i < by;++i) {
      ++cp;
    }
    return cp;
  }
 
  bool operator==(IterT otherIter) const {
    return iter == otherIter;
  }
 
  bool operator!=(IterT otherIter) const {
    return iter != otherIter;
  }
 
  friend bool operator!=(IterT otherIter,filtered_iterator_proxy<Coll,Pred> thisIter) {
    return otherIter != thisIter.iter;
  }
 
  friend bool operator==(IterT otherIter,filtered_iterator_proxy<Coll,Pred> thisIter) {
    return otherIter == thisIter.iter;
  }
 
  IterT& wrapped() {
    return iter;
  }
 
  IterT& end() {
    return endIter;
  }
 
  bool ended() {
    return endIter == iter;
  }
 
  Coll& collection() const {
    return coll;
  }
 
  Pred predicate() const {
    return filter.predicate();
  }
 
private:
  Coll& coll;
  IterT iter;
  IterT endIter;
  filter_fn<Pred> filter;
 
  // Need this function so as not to incorrectly always filter the first value in the underlying proxy
  void moveToFirst() {
    while (endIter != iter && !filter(*iter)) {
      ++iter;
    };
  }
 
  void moveToNext() {
    if (endIter == iter) return; // guard
    do {
      ++iter;
    } while (endIter != iter && !filter(*iter));
  }
};
 
template <typename Pred>
struct filter {
public:
  filter(const Pred& pred) : pred(pred) {}
  ~filter() = default;
 
  template <typename Coll>
  auto operator()(Coll& c) -> filtered_iterator_proxy<Coll,Pred> {
    return filtered_iterator_proxy<Coll,Pred>(c,pred);
  }
  
  template <typename OtherColl, typename OtherPred> // first argument must be l-value below
  friend auto operator|(filtered_iterator_proxy<OtherColl,OtherPred> c,filter<Pred> pred) -> filtered_iterator_proxy<OtherColl,dual_filter<OtherPred,Pred>> {
    return filtered_iterator_proxy<OtherColl,dual_filter<OtherPred,Pred>>(c.collection(),dual_filter(c.predicate(),pred.pred));
  }
 
  template <typename Coll>
  friend auto operator|(Coll& c,filter<Pred> pred) -> filtered_iterator_proxy<Coll,Pred> {
    return filtered_iterator_proxy<Coll,Pred>(c,pred.pred);
  }
 
private:
  Pred pred;
};
 
struct to_view {
  to_view() = default;
  ~to_view() = default;
 
  // convert something with a proxy (likely a filtered iterator proxy) into a view
  template <typename IterProxyT>
  friend auto operator|(IterProxyT proxy,to_view view) -> herald::analysis::views::view<IterProxyT> {
    return herald::analysis::views::view<IterProxyT>(proxy);
  }
  
  // template <typename Coll,
  //           typename IterProxyT = iterator_proxy<Coll>, 
  //           std::enable_if_t<!std::is_same_v<Coll,iterator_proxy> && !std::is_same_v<Coll,filtered_iterator_proxy>, bool> = true
  //          >
  // friend auto operator|(Coll coll,to_view view) -> herald::analysis::views::view<IterProxyT> {
  //   return herald::analysis::views::view<IterProxyT>(iterator_proxy<Coll>(coll));
  // }
  
  template <typename SampleT,
            std::size_t ListSize,
            typename IterProxyT = iterator_proxy<herald::analysis::sampling::SampleList<SampleT,ListSize>>
           >
  friend auto operator|(herald::analysis::sampling::SampleList<SampleT,ListSize>& coll,to_view view) -> herald::analysis::views::view<IterProxyT> {
    return herald::analysis::views::view<IterProxyT>(iterator_proxy<herald::analysis::sampling::SampleList<SampleT,ListSize>>(coll));
  }
};
 
} // end namespace views
}
}
 
#endif