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