mapping.hpp

Go to the documentation of this file.

// vim: set tabstop=2:softtabstop=2:shiftwidth=2:expandtab

#ifndef LIN_CORE_TYPES_MAPPING_HPP_
#define LIN_CORE_TYPES_MAPPING_HPP_

#include "../config.hpp"
#include "../traits.hpp"
#include "stream.hpp"

#include <initializer_list>
#include <type_traits>
#include <utility>

namespace lin {
namespace internal {

template <class D>
class Mapping : public Stream<D> {
  static_assert(has_valid_traits<D>::value,
      "Derived types to Mapping<...> must have valid traits");

 private:
  template <typename T, typename U>
  using assign_expr = decltype(std::declval<T &>() = std::declval<U &>());

 public:
  typedef traits<D> Traits;

 protected:
  using Stream<D>::derived;

 public:
  using Stream<D>::rows;
  using Stream<D>::cols;
  using Stream<D>::size;
  using Stream<D>::eval;

  constexpr Mapping() = default;
  constexpr Mapping(Mapping<D> const &) = default;
  constexpr Mapping(Mapping<D> &&) = default;
  constexpr Mapping<D> &operator=(Mapping<D> const &) = default;
  constexpr Mapping<D> &operator=(Mapping<D> &&) = default;

  inline constexpr typename Traits::elem_t &operator()(size_t i, size_t j) {
    return derived()(i, j);
  }

  inline constexpr typename Traits::elem_t operator()(size_t i, size_t j) const {
    return const_cast<D &>(derived())(i, j);
  }

  inline constexpr typename Traits::elem_t &operator()(size_t i) {
    return derived()(i);
  }

  inline constexpr typename Traits::elem_t operator()(size_t i) const {
    return const_cast<D &>(derived())(i);
  }

  inline constexpr typename Traits::elem_t &operator[](size_t i) {
    return derived()(i);
  }

  inline constexpr typename Traits::elem_t operator[](size_t i) const {
    return const_cast<D &>(derived())(i);
  }

  template <typename T, std::enable_if_t<
      is_detected<assign_expr, typename Traits::elem_t, T>::value, size_t> = 0>
  constexpr D &operator=(std::initializer_list<T> const &list) {
    LIN_ASSERT(size() == list.size());

    size_t i = 0;
    for (T const &l : list) (*this)(i++) = l;
    return derived();
  }

  template <class C, std::enable_if_t<conjunction<
      have_same_dimensions<D, C>,
      is_detected<assign_expr, typename Traits::elem_t, traits_elem_t<C>>
    >::value, size_t> = 0>
  constexpr D &operator=(Stream<C> const &s) {
    LIN_ASSERT(rows() == s.rows());
    LIN_ASSERT(cols() == s.cols());

    for (size_t i = 0; i < size(); i++) (*this)(i) = s(i);
    return derived();
  }
};
}  // namespace internal
}  // namespace lin

#endif