cpp-lazy-stream/include/stream/view.h

//
//  view.h
//  stream
//
//  Created by Sam Jaffe on 3/29/23.
//

#pragma once

namespace stream::ranges {

template <typename T> class view {
public:
  class iterator : public facade<iterator> {
  private:
    T (*dereference_)(void *){nullptr};
    bool (*equal_to_)(void *, void *){nullptr};
    void (*increment_)(void *){nullptr};
    std::shared_ptr<void> impl_{nullptr};

  public:
    template <typename It>
    iterator(It impl)
        : dereference_([](void * p) -> T { return **((It *)p); }),
          equal_to_(
              [](void * l, void * r) { return *((It *)l) == *((It *)r); }),
          increment_([](void * p) { ++(*(It *)(p)); }),
          impl_(std::make_shared<It>(impl)) {}

    T dereference() const { return dereference_(impl_.get()); }
    void increment() { increment_(impl_.get()); }
    bool equal_to(iterator const & other) const {
      return impl_ == other.impl_ ||
             (impl_ && other.impl_ &&
              equal_to_(impl_.get(), other.impl_.get()));
    }
  };

private:
  std::shared_ptr<void> impl_{nullptr};
  iterator (*begin_)(void *){nullptr};
  iterator (*end_)(void *){nullptr};

public:
  template <typename S>
  view(std::shared_ptr<S> impl)
      : impl_(impl), begin_([](void * p) -> iterator {
          return static_cast<S *>(p)->begin();
        }),
        end_([](void * p) -> iterator { return static_cast<S *>(p)->end(); }) {}

  template <typename S>
  view(S & impl) : view(std::shared_ptr<S>(&impl, [](void *) {})) {}

  template <typename S>
  view(S const & impl) : view(std::shared_ptr<S const>(&impl, [](void *) {})) {}

  template <typename S>
  view(S && impl) : view(std::make_shared<S>(std::forward<S>(impl))) {}

  auto begin() const { return begin_(impl_.get()); }
  auto end() const { return end_(impl_.get()); }
  bool empty() const { return begin() == end(); }
};

}