checkout_span.hpp

Go to the documentation of this file.

#pragma once
 
#include "ityr/common/util.hpp"
#include "ityr/ori/ori.hpp"
#include "ityr/container/global_span.hpp"
 
namespace ityr {
 
namespace checkout_mode {
 
using read_t = ori::mode::read_t;
 
inline constexpr read_t read;
 
using write_t = ori::mode::write_t;
 
inline constexpr write_t write;
 
using read_write_t = ori::mode::read_write_t;
 
inline constexpr read_write_t read_write;
 
struct no_access_t {};
 
inline constexpr no_access_t no_access;
 
}
 
template <typename T, typename Mode>
class checkout_span {
public:
  using element_type           = T;
  using value_type             = std::remove_cv_t<element_type>;
  using size_type              = std::size_t;
  using pointer                = element_type*;
  using const_pointer          = std::add_const_t<element_type>*;
  using difference_type        = typename std::iterator_traits<pointer>::difference_type;
  using reference              = typename std::iterator_traits<pointer>::reference;
  using const_reference        = typename std::iterator_traits<const_pointer>::reference;
  using iterator               = pointer;
  using const_iterator         = const_pointer;
  using reverse_iterator       = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
  checkout_span() {}
 
  explicit checkout_span(ori::global_ptr<T> gptr, std::size_t n, Mode)
    : ptr_((gptr && n > 0) ? ori::checkout(gptr, n, Mode{}) : nullptr),
      n_(n) {
    ITYR_CHECK(((ptr_ && n_ > 0) || (!ptr_ && n == 0)));
  }
 
  ~checkout_span() { destroy(); }
 
  checkout_span(const checkout_span&) = delete;
  checkout_span& operator=(const checkout_span&) = delete;
 
  checkout_span(checkout_span&& cs) : ptr_(cs.ptr_), n_(cs.n_) { cs.ptr_ = nullptr; cs.n_ = 0; }
  checkout_span& operator=(checkout_span&& cs) {
    destroy();
    ptr_ = cs.ptr_;
    n_   = cs.n_;
    cs.ptr_ = nullptr;
    cs.n_   = 0;
    return *this;
  }
 
  constexpr pointer data() const noexcept { return ptr_; }
  constexpr size_type size() const noexcept { return n_; }
 
  constexpr iterator begin() const noexcept { return ptr_; }
  constexpr iterator end() const noexcept { return ptr_ + n_; }
 
  constexpr const_iterator cbegin() const noexcept { return ptr_; }
  constexpr const_iterator cend() const noexcept { return ptr_ + n_; }
 
  constexpr reverse_iterator rbegin() const noexcept { return std::make_reverse_iterator(end()); }
  constexpr reverse_iterator rend() const noexcept { return std::make_reverse_iterator(begin()); }
 
  constexpr const_reverse_iterator crbegin() const noexcept { return std::make_reverse_iterator(cend()); }
  constexpr const_reverse_iterator crend() const noexcept { return std::make_reverse_iterator(begin()); }
 
  constexpr reference operator[](size_type i) const { assert(i <= n_); return ptr_[i]; }
 
  constexpr reference front() const { return *ptr_; }
  constexpr reference back() const { return *(ptr_ + n_ - 1); }
 
  constexpr bool empty() const noexcept { return n_ == 0; }
 
  void checkout(ori::global_ptr<T> gptr, std::size_t n, Mode) {
    checkin();
    ptr_ = ori::checkout(gptr, n, Mode{});
    n_ = n;
  }
 
  void checkout_nb(ori::global_ptr<T> gptr, std::size_t n, Mode) {
    checkin();
    ptr_ = ori::checkout_nb(gptr, n, Mode{}).first;
    n_ = n;
  }
 
  void checkin() {
    if (ptr_) {
      ori::checkin(ptr_, n_, Mode{});
      ptr_ = nullptr;
      n_   = 0;
    }
  }
 
private:
  void destroy() {
    if (ptr_) {
      ori::checkin(ptr_, n_, Mode{});
    }
  }
 
  pointer   ptr_ = nullptr;
  size_type n_   = 0;
};
 
template <typename T, typename Mode>
inline constexpr auto data(const checkout_span<T, Mode>& cs) noexcept {
  return cs.data();
}
 
template <typename T, typename Mode>
inline constexpr auto size(const checkout_span<T, Mode>& cs) noexcept {
  return cs.size();
}
 
template <typename T, typename Mode>
inline constexpr auto begin(const checkout_span<T, Mode>& cs) noexcept {
  return cs.begin();
}
 
template <typename T, typename Mode>
inline constexpr auto end(const checkout_span<T, Mode>& cs) noexcept {
  return cs.end();
}
 
template <typename T, typename Mode>
inline checkout_span<T, Mode> make_checkout(ori::global_ptr<T> gptr, std::size_t n, Mode mode) {
  return checkout_span<T, Mode>{gptr, n, mode};
}
 
template <typename T, typename Mode>
inline checkout_span<T, Mode> make_checkout(global_span<T> gspan, Mode mode) {
  return checkout_span<T, Mode>{gspan.data(), gspan.size(), mode};
}
 
namespace internal {
 
inline auto make_checkouts_aux() {
  return std::make_tuple();
}
 
template <typename T, typename Mode, typename... Rest>
inline auto make_checkouts_aux(ori::global_ptr<T> gptr, std::size_t n, Mode mode, Rest&&... rest) {
  checkout_span<T, Mode> cs;
  cs.checkout_nb(gptr, n, mode);
  return std::tuple_cat(std::make_tuple(std::move(cs)),
                        make_checkouts_aux(std::forward<Rest>(rest)...));
}
 
template <typename T, typename Mode, typename... Rest>
inline auto make_checkouts_aux(global_span<T> gspan, Mode mode, Rest&&... rest) {
  checkout_span<T, Mode> cs;
  cs.checkout_nb(gspan.data(), gspan.size(), mode);
  return std::tuple_cat(std::make_tuple(std::move(cs)),
                        make_checkouts_aux(std::forward<Rest>(rest)...));
}
 
}
 
template <typename... Args>
inline auto make_checkouts(Args&&... args) {
  auto css = internal::make_checkouts_aux(std::forward<Args>(args)...);
  ori::checkout_complete();
  return css;
}
 
}