indices.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception

#ifndef DUNE_COMMON_INDICES_HH
#define DUNE_COMMON_INDICES_HH

#include <cstddef>
#include <stdexcept>
#include <type_traits>
#include <utility>

namespace Dune
{
  template<std::size_t i>
  using index_constant = std::integral_constant<std::size_t, i>;



  namespace Indices
  {
    inline constexpr index_constant< 0>  _0 = {};

    inline constexpr index_constant< 1>  _1 = {};

    inline constexpr index_constant< 2>  _2 = {};

    inline constexpr index_constant< 3>  _3 = {};

    inline constexpr index_constant< 4>  _4 = {};

    inline constexpr index_constant< 5>  _5 = {};

    inline constexpr index_constant< 6>  _6 = {};

    inline constexpr index_constant< 7>  _7 = {};

    inline constexpr index_constant< 8>  _8 = {};

    inline constexpr index_constant< 9>  _9 = {};

    inline constexpr index_constant<10> _10 = {};

    inline constexpr index_constant<11> _11 = {};

    inline constexpr index_constant<12> _12 = {};

    inline constexpr index_constant<13> _13 = {};

    inline constexpr index_constant<14> _14 = {};

    inline constexpr index_constant<15> _15 = {};

    inline constexpr index_constant<16> _16 = {};

    inline constexpr index_constant<17> _17 = {};

    inline constexpr index_constant<18> _18 = {};

    inline constexpr index_constant<19> _19 = {};

  } // namespace Indices

  template<class F, class I, I... i>
  decltype(auto) constexpr unpackIntegerSequence(F&& f, [[maybe_unused]] std::integer_sequence<I, i...> sequence)
  {
    return f(std::integral_constant<I, i>()...);
  }


  namespace Indices { inline namespace Literals
  {
    namespace Impl
    {
      // convert a single character into an unsigned integer
      constexpr unsigned char2digit (const char c)
      {
        if (c >= '0' && c <= '9')
          return unsigned(c) - unsigned('0');
        else {
          throw std::invalid_argument("Character is not a digit.");
          return 0u;
        }
      }

      // convert a sequence of character digits into an unsigned integer
      template <class T, char... digits>
      constexpr T chars2number ()
      {
        const char arr[] = {digits...};
        T result = 0;
        T power  = 1;
        const T base = 10;

        const int N = sizeof...(digits);
        for (int i = 0; i < N; ++i) {
            char c = arr[N - 1 - i];
            result+= char2digit(c) * power;
            power *= base;
        }

        return result;
      }

    } //namespace Impl

    template <char... digits>
    constexpr auto operator""_ic()
    {
      return std::integral_constant<std::size_t, Impl::chars2number<std::size_t,digits...>()>{};
    }

    template <char... digits>
    constexpr auto operator""_uc()
    {
      return std::integral_constant<unsigned, Impl::chars2number<unsigned,digits...>()>{};
    }

    template <char... digits>
    constexpr auto operator""_sc()
    {
      return std::integral_constant<int, Impl::chars2number<int,digits...>()>{};
    }

    template <class T, T value>
    constexpr auto operator- (std::integral_constant<T,value>)
    {
      return std::integral_constant<std::make_signed_t<T>, -value>{};
    }

  }} //namespace Indices::Literals
} //namespace Dune

#endif // DUNE_COMMON_INDICES_HH