FakeContainer.hpp

#pragma once
 
#include <cstddef>
#include <iterator>
 
namespace AMDiS
{
  struct FakeAssigner
  {
    template <class T>
    constexpr FakeAssigner& operator=(T&&) noexcept { return *this; }
 
    template <class T>
    constexpr FakeAssigner& operator+=(T&&) noexcept { return *this; }
 
    template <class T>
    constexpr FakeAssigner& operator-=(T&&) noexcept { return *this; }
 
    template <class T>
    constexpr FakeAssigner& operator*=(T&&) noexcept { return *this; }
 
    template <class T>
    constexpr FakeAssigner& operator/=(T&&) noexcept { return *this; }
  };
 
 
  template <class T, T value>
  class FakeContainer
      : public FakeAssigner
  {
  public:
    using value_type = T;
    using size_type = std::size_t;
 
    struct const_iterator
    {
      using value_type = T;
      using reference = T;
      using difference_type = std::ptrdiff_t;
      using iterator_category = std::forward_iterator_tag;
 
      constexpr T operator*() const noexcept { return value; }
      constexpr const_iterator& operator++() noexcept { return *this; }
      constexpr const_iterator  operator++(int) noexcept { return *this; }
 
      constexpr bool operator==(const_iterator) const noexcept { return true; }
      constexpr bool operator!=(const_iterator) const noexcept { return false; }
    };
 
 
  public: // constructor
 
    template <class... Args>
    constexpr explicit FakeContainer(Args&&...) noexcept {}
 
    template <class S>
    constexpr void init(S const&, bool) noexcept { /* do nothing */ }
    constexpr void finish() noexcept { /* do nothing */ }
 
 
  public: // modifiers and capacity
 
    template <class... Args>
    constexpr void scatter(Args&&...) noexcept { /* do nothing */ }
 
    template <class Arg>
    constexpr void push_back(Arg&&) noexcept { /* do nothing */ }
 
    template <class... Args>
    constexpr void emplace_back(Args&&...) noexcept { /* do nothing */ }
 
    template <class Size>
    constexpr void reserve(Size&&) noexcept { /* do nothing */ }
 
    template <class Size>
    constexpr void resize(Size&&) noexcept { /* do nothing */ }
 
    constexpr bool empty() const noexcept { return false; }
 
 
  public: // element access
 
    template <class Index>
    constexpr FakeContainer& operator[](Index&&) noexcept { return *this; }
 
    template <class Index>
    constexpr FakeContainer const& operator[](Index&&) const noexcept { return *this; }
 
    template <class Index>
    constexpr FakeContainer& at(Index&&) noexcept { return *this; }
 
    template <class Index>
    constexpr FakeContainer const& at(Index&&) const noexcept { return *this; }
 
 
    constexpr FakeContainer&       front()       noexcept { return *this; }
    constexpr FakeContainer const& front() const noexcept { return *this; }
 
 
    constexpr operator T() const noexcept { return value; }
 
 
  public: // iterators
 
    constexpr const_iterator begin() const noexcept { return const_iterator{}; }
 
    constexpr const_iterator cbegin() const noexcept { return const_iterator{}; }
 
 
  public: // assignment operators
 
    using FakeAssigner::operator=;
    using FakeAssigner::operator+=;
    using FakeAssigner::operator-=;
    using FakeAssigner::operator*=;
    using FakeAssigner::operator/=;
  };
 
} // end namespace AMDiS