table_indices.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_table_indices_h
#define dealii_table_indices_h


#include <deal.II/base/config.h>

#include <deal.II/base/exceptions.h>

#include <algorithm>
#include <iterator>
#include <ostream>


DEAL_II_NAMESPACE_OPEN


template <int N>
class TableIndices
{
public:
  static_assert(N > 0,
                "TableIndices objects need to represent at least one index.");


  TableIndices();

  explicit TableIndices(const std::size_t index0);

  TableIndices(const std::size_t index0, const std::size_t index1);

  TableIndices(const std::size_t index0,
               const std::size_t index1,
               const std::size_t index2);

  TableIndices(const std::size_t index0,
               const std::size_t index1,
               const std::size_t index2,
               const std::size_t index3);

  TableIndices(const std::size_t index0,
               const std::size_t index1,
               const std::size_t index2,
               const std::size_t index3,
               const std::size_t index4);

  DEAL_II_DEPRECATED
  TableIndices(const std::size_t index0,
               const std::size_t index1,
               const std::size_t index2,
               const std::size_t index3,
               const std::size_t index4,
               const std::size_t index5,
               const std::size_t index6 = numbers::invalid_unsigned_int,
               const std::size_t index7 = numbers::invalid_unsigned_int,
               const std::size_t index8 = numbers::invalid_unsigned_int);

  std::size_t operator[](const unsigned int i) const;

  std::size_t &operator[](const unsigned int i);

  bool
  operator==(const TableIndices<N> &other) const;

  bool
  operator!=(const TableIndices<N> &other) const;

  void
  sort();

  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);

protected:
  std::size_t indices[N];
};



/* --------------------- Template and inline functions ---------------- */


template <int N>
TableIndices<N>::TableIndices()
{
  for (unsigned int i = 0; i < N; ++i)
    indices[i] = 0;
}



template <int N>
TableIndices<N>::TableIndices(const std::size_t index0)
{
  static_assert(
    N == 1, "This constructor is only available for TableIndices<1> objects.");
  indices[0] = index0;
}



template <int N>
TableIndices<N>::TableIndices(const std::size_t index0,
                              const std::size_t index1)
{
  static_assert(
    N == 2, "This constructor is only available for TableIndices<2> objects.");
  indices[0] = index0;
  indices[1] = index1;
}



template <int N>
TableIndices<N>::TableIndices(const std::size_t index0,
                              const std::size_t index1,
                              const std::size_t index2)
{
  static_assert(
    N == 3, "This constructor is only available for TableIndices<3> objects.");
  indices[0] = index0;
  indices[1] = index1;
  indices[2] = index2;
}



template <int N>
TableIndices<N>::TableIndices(const std::size_t index0,
                              const std::size_t index1,
                              const std::size_t index2,
                              const std::size_t index3)
{
  static_assert(
    N == 4, "This constructor is only available for TableIndices<4> objects.");
  indices[0] = index0;
  indices[1] = index1;
  indices[2] = index2;
  indices[3] = index3;
}



template <int N>
TableIndices<N>::TableIndices(const std::size_t index0,
                              const std::size_t index1,
                              const std::size_t index2,
                              const std::size_t index3,
                              const std::size_t index4)
{
  static_assert(
    N == 5, "This constructor is only available for TableIndices<5> objects.");
  indices[0] = index0;
  indices[1] = index1;
  indices[2] = index2;
  indices[3] = index3;
  indices[4] = index4;
}



template <int N>
TableIndices<N>::TableIndices(const std::size_t index0,
                              const std::size_t index1,
                              const std::size_t index2,
                              const std::size_t index3,
                              const std::size_t index4,
                              const std::size_t index5,
                              const std::size_t index6,
                              const std::size_t index7,
                              const std::size_t index8)
{
  switch (N)
    {
      case 1:
        Assert(index1 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 2:
        Assert(index2 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 3:
        Assert(index3 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 4:
        Assert(index4 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 5:
        Assert(index5 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 6:
        Assert(index6 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 7:
        Assert(index7 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        DEAL_II_FALLTHROUGH;
      case 8:
        Assert(index8 == numbers::invalid_unsigned_int,
               ExcMessage("more than N index values provided"));
        break;
      default:;
    }

  // Always access "indices" with indices modulo N to avoid bogus compiler
  // warnings (although such access is always in dead code...
  switch (N)
    {
      default:
        // For TableIndices of size 10 or larger als default initialize the
        // remaining indices to numbers::invalid_unsigned_int:
        for (unsigned int i = 0; i < N; ++i)
          indices[i] = numbers::invalid_unsigned_int;
        DEAL_II_FALLTHROUGH;
      case 9:
        indices[8 % N] = index8;
        DEAL_II_FALLTHROUGH;
      case 8:
        indices[7 % N] = index7;
        DEAL_II_FALLTHROUGH;
      case 7:
        indices[6 % N] = index6;
        DEAL_II_FALLTHROUGH;
      case 6:
        indices[5 % N] = index5;
        DEAL_II_FALLTHROUGH;
      case 5:
        indices[4 % N] = index4;
        DEAL_II_FALLTHROUGH;
      case 4:
        indices[3 % N] = index3;
        DEAL_II_FALLTHROUGH;
      case 3:
        indices[2 % N] = index2;
        DEAL_II_FALLTHROUGH;
      case 2:
        indices[1 % N] = index1;
        DEAL_II_FALLTHROUGH;
      case 1:
        indices[0 % N] = index0;
    }
}


template <int N>
inline std::size_t TableIndices<N>::operator[](const unsigned int i) const
{
  AssertIndexRange(i, N);
  return indices[i];
}


template <int N>
inline std::size_t &TableIndices<N>::operator[](const unsigned int i)
{
  AssertIndexRange(i, N);
  return indices[i];
}


template <int N>
inline bool
TableIndices<N>::operator==(const TableIndices<N> &other) const
{
  for (unsigned int i = 0; i < N; ++i)
    if (indices[i] != other.indices[i])
      return false;
  return true;
}


template <int N>
inline bool
TableIndices<N>::operator!=(const TableIndices<N> &other) const
{
  return !(*this == other);
}


template <int N>
inline void
TableIndices<N>::sort()
{
  std::sort(std::begin(indices), std::end(indices));
}


template <int N>
template <class Archive>
inline void
TableIndices<N>::serialize(Archive &ar, const unsigned int)
{
  ar &indices;
}


template <int N>
std::ostream &
operator<<(std::ostream &out, const TableIndices<N> &indices)
{
  out << '[';
  for (unsigned int i = 0; i < N; ++i)
    {
      out << indices[i];
      if (i + 1 != N)
        out << ',';
    }
  out << ']';

  return out;
}


DEAL_II_NAMESPACE_CLOSE

#endif