cpp-lazy-stream/streams/streams.hpp

#pragma once

#include <algorithm>
#include <memory>
#include <numeric>

#define DELEGATE_ITERATOR_IMPL_BASE(impl) \
  bool operator==(iterator const&other) const { \
    return impl == other.impl; \
  }

#define DELEGATE_ITERATOR_IMPL(impl) \
  DELEGATE_ITERATOR_IMPL_BASE(impl) \
  iterator& operator++() { \
    ++impl; \
    return *this; \
  }

std::map<void*, bool> data;

namespace stream {
#define STREAM_ITERATOR_COPY() \
  copy(other.copy), dereference(other.dereference), compare(other.compare), destroy(other.destroy), advance(other.advance), type_(other.type_)
  
  template <typename T>
  class iterator {
  public:
    using value_type = typename std::remove_reference<T>::type;
    using reference = value_type &;
    using pointer = value_type *;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
  public:
    iterator() = default;
    
    template <typename Iter>
    iterator(Iter impl) {
      copy = [](void * p) { return (void*) new Iter(*(Iter*)(p)); };
      dereference = [](void * p) -> T { return **((Iter*)p); };
      compare = [](void * l, void * r) { return *((Iter*)l) == *((Iter*)r); };
      destroy = [](void * p) { delete (Iter*)(p); };
      advance = [](void * p) { ++(*(Iter*)(p)); };
      type_ = typeid(Iter).name();
      impl_ = copy(&impl);
    }
    
    iterator(iterator const& other)
    : STREAM_ITERATOR_COPY()
    , impl_(copy(other.impl_)) {
    }
    
    iterator(iterator && other)
    : STREAM_ITERATOR_COPY()
    , impl_(other.impl_) {
      other.impl_ = nullptr;
    }
    
    iterator & operator=(iterator const & other) {
      return *this = iterator{other};
    }

    iterator & operator=(iterator && other) {
      swap(*this, other);
      return *this;
    }

    ~iterator() { if (destroy) destroy(impl_); }
    
    T operator*() const { return dereference(impl_); }
    iterator& operator++() { advance(impl_); return *this; }
    bool operator==(iterator const&other) const {
      if (strcmp(type_, other.type_)) { return false; }
      return compare(impl_, other.impl_);
    }
    bool operator!=(iterator const&other) const {
      if (strcmp(type_, other.type_)) { return false; }
      return !compare(impl_, other.impl_);
    }
  private:
    friend void swap(iterator & lhs, iterator & rhs) {
      using std::swap;
      swap(lhs.copy, rhs.copy);
      swap(lhs.dereference, rhs.dereference);
      swap(lhs.compare, rhs.compare);
      swap(lhs.destroy, rhs.destroy);
      swap(lhs.advance, rhs.advance);
      swap(lhs.type_, rhs.type_);
      swap(lhs.impl_, rhs.impl_);
    }
    using delegate = void(*)(void*);
    void* (*copy)(void*){nullptr};
    T (*dereference)(void*){nullptr};
    bool (*compare)(void*, void*){nullptr};
    delegate destroy{nullptr}, advance{nullptr};
    char const * type_{nullptr};
    void * impl_{nullptr};
  };
  
  namespace detail {
    template <typename T, typename = void>
    class stream_base_pointer_impl {};
    
    template <typename T>
    class stream_base_pointer_impl<T, typename std::enable_if<detail::is_dereferencable<typename std::remove_reference<T>::type>::value>::type> {
    private:
      using self = stream_base<T>;
      using noref = typename std::remove_reference<T>::type;
      using element_type = typename std::pointer_traits<noref>::element_type;
    public:
      auto deref() const & -> stream_base<element_type &> {
        return static_cast<stream_base<T> const *>(this)->map([](T const & p) -> element_type & { return *p; });
      }
      
      auto deref() && -> stream_base<element_type &> {
        return static_cast<stream_base<T> &&>(*this).map([](T const & p) -> element_type & { return *p; });
      }
    };
    
    template <typename T>
    class stream_base : public stream_base_pointer_impl<T> {
    private:
      template <typename F>
      using map_f = decltype(std::declval<F>()(std::declval<T>()));
      template <typename F>
      using flatmap_f = typename decltype(std::declval<F>()(std::declval<T>()))::value_type;
      template <typename F>
      using memvar_f = typename map_member_object<F>::type;
      template <typename F>
      using memfun_f = typename map_member_function<F>::type;
      template <typename F>
      using is_memvar = std::is_member_object_pointer<F>;
      template <typename F>
      using is_memfun = std::is_member_function_pointer<F>;

      using self = stream_base<T>;
      using noref = typename std::remove_reference<T>::type;
      using clean = typename std::decay<T>::type;
    public:
      template <typename Stream>
      stream_base(std::shared_ptr<Stream> && impl) {
        do_begin = [](std::shared_ptr<void> p) -> iterator<T> { return std::static_pointer_cast<Stream>(p)->begin(); };
        do_end = [](std::shared_ptr<void> p) -> iterator<T> { return std::static_pointer_cast<Stream>(p)->end(); };
        impl_ = std::static_pointer_cast<void>(impl);
      }
      
      ::stream::iterator<T> begin() const { return do_begin(impl_); }
      ::stream::iterator<T> end  () const { return do_end  (impl_); }
      
      bool empty() const { return begin() == end(); }
      
      std::vector<clean> collect() const {
        std::vector<clean> coll;
        collect(coll);
        return coll;
      }
      
      template <typename C, typename = typename std::enable_if<!std::is_void<typename C::value_type>::value, void>::type>
      C& collect(C & coll) const {
        std::copy(begin(), end(), std::inserter(coll, coll.end()));
        return coll;
      }
      
      template <typename F>
      clean accumulate(F&& fold, clean const& accum) const {
        return std::accumulate(begin(), end(), accum, fold);
      }
      
      clean accumulate(clean const& accum) const {
        return std::accumulate(begin(), end(), accum);
      }
      
      template <typename F>
      void each(F && consumer) const {
        std::for_each(begin(), end(), consumer);
      }
      
      template <typename F>
      stream_base<map_f<F>> map(F&& func) const &;
      template <typename F>
      stream_base<T> filter(F&& func) const &;
      template <typename F>
      stream_base<flatmap_f<F>> flatmap(F&& func) const &;
      
      template <typename F>
      stream_base<map_f<F>> map(F&& func) &&;
      template <typename F>
      stream_base<T> filter(F&& func) &&;
      template <typename F>
      stream_base<flatmap_f<F>> flatmap(F&& func) &&;
      
      template <typename Cast>
      auto cast() const & -> stream_base<Cast const &> {
        return map([](T const & p) -> Cast const & { return p; });
      }
      
      template <typename Cast>
      auto cast() && -> stream_base<Cast const &> {
        return std::move(*this).map([](T const & p) -> Cast const & { return p; });
      }
      
      template <typename F, typename = typename std::enable_if<is_memvar<F>::value>::type>
      auto map(F && memvar) const & -> stream_base<memvar_f<F>> {
        return map(map_member_object<F>{memvar});
      }
      
      template <typename F, typename = typename std::enable_if<is_memfun<F>::value>::type>
      auto map(F && memvar) const & -> stream_base<memfun_f<F>> {
        return map(map_member_function<F>{memvar});
      }

      template <typename F, typename = typename std::enable_if<is_memvar<F>::value>::type>
      auto map(F && memvar) && -> stream_base<memvar_f<F>> {
        return std::move(*this).map(map_member_object<F>{memvar});
      }

      template <typename F, typename = typename std::enable_if<is_memfun<F>::value>::type>
      auto map(F && memvar) && -> stream_base<memfun_f<F>> {
        return std::move(*this).map(map_member_function<F>{memvar});
      }
    private:
      iterator<T> (*do_begin)(std::shared_ptr<void>){nullptr};
      iterator<T> (*do_end)(std::shared_ptr<void>){nullptr};
      std::shared_ptr<void> impl_{nullptr};
    };
  }
}