table_indices.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2005 - 2020 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 <deal.II/base/template_constraints.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.");
 
 
  constexpr TableIndices() = default;
 
  template <typename... T>
  constexpr TableIndices(const T... indices);
 
  DEAL_II_CONSTEXPR std::size_t operator[](const unsigned int i) const;
 
  DEAL_II_CONSTEXPR std::size_t &operator[](const unsigned int i);
 
  constexpr bool
  operator==(const TableIndices<N> &other) const;
 
  constexpr bool
  operator!=(const TableIndices<N> &other) const;
 
  DEAL_II_CONSTEXPR 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>
template <typename... T>
constexpr TableIndices<N>::TableIndices(const T... args)
  : indices{static_cast<const unsigned int>(args)...}
{
  static_assert(internal::TemplateConstraints::all_true<
                  std::is_integral<T>::value...>::value,
                "Not all of the parameters have integral type!");
  static_assert(sizeof...(T) == N, "Wrong number of constructor arguments!");
}
 
 
template <int N>
DEAL_II_CONSTEXPR inline std::size_t TableIndices<N>::
                                     operator[](const unsigned int i) const
{
  AssertIndexRange(i, N);
  return indices[i];
}
 
 
template <int N>
DEAL_II_CONSTEXPR inline std::size_t &TableIndices<N>::
                                      operator[](const unsigned int i)
{
  AssertIndexRange(i, N);
  return indices[i];
}
 
 
template <int N>
constexpr bool
TableIndices<N>::operator==(const TableIndices<N> &other) const
{
  return std::equal(std::begin(indices),
                    std::end(indices),
                    std::begin(other.indices));
}
 
 
template <int N>
constexpr bool
TableIndices<N>::operator!=(const TableIndices<N> &other) const
{
  return !(*this == other);
}
 
 
template <int N>
DEAL_II_CONSTEXPR 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