simple_id.hh

Go to the documentation of this file.

/*
    @@@@@@@@  @@           @@@@@@   @@@@@@@@ @@
   /@@/////  /@@          @@////@@ @@////// /@@
   /@@       /@@  @@@@@  @@    // /@@       /@@
   /@@@@@@@  /@@ @@///@@/@@       /@@@@@@@@@/@@
   /@@////   /@@/@@@@@@@/@@       ////////@@/@@
   /@@       /@@/@@//// //@@    @@       /@@/@@
   /@@       @@@//@@@@@@ //@@@@@@  @@@@@@@@ /@@
   //       ///  //////   //////  ////////  //

   Copyright (c) 2016, Triad National Security, LLC
   All rights reserved.
                                                                              */
#pragma once

// system headers
#include <iostream>
#include <tuple>

namespace flecsi {
namespace util {

namespace detail {

template<typename... Ts>
class are_integral : public std::integral_constant<bool, true>
{};

template<typename T, typename... Ts>
class are_integral<T, Ts...>
  : public std::integral_constant<bool,
      (std::is_integral<T>::value && are_integral<Ts...>::value)>
{};

template<typename... Ts>
constexpr bool are_integral_v = are_integral<Ts...>::value;


// This function terminates the chain
template<std::size_t I = 0,
  typename TupleA,
  typename TupleB,
  std::enable_if_t<std::tuple_size<TupleA>::value ==
                     std::tuple_size<TupleB>::value &&
                   I == std::tuple_size<TupleA>::value - 1> * = nullptr>
bool
less_than(const TupleA & a, const TupleB & b) {
  return (std::get<I>(a) < std::get<I>(b));
}

// this function is the main one
template<std::size_t I = 0,
  typename TupleA,
  typename TupleB,
  typename = std::enable_if_t<std::tuple_size<TupleA>::value ==
                                std::tuple_size<TupleB>::value &&
                              (I < std::tuple_size<TupleA>::value - 1) &&
                              std::tuple_size<TupleA>::value >= 2>>
bool
less_than(const TupleA & a, const TupleB & b) {
  if(std::get<I>(a) == std::get<I>(b))
    return less_than<I + 1>(a, b);
  else
    return (std::get<I>(a) < std::get<I>(b));
}


// this one terminates the chain
template<std::size_t I = 0,
  typename TupleA,
  typename TupleB,
  std::enable_if_t<std::tuple_size<TupleA>::value ==
                     std::tuple_size<TupleB>::value &&
                   I == std::tuple_size<TupleA>::value - 1> * = nullptr>
bool
equal_to(const TupleA & a, const TupleB & b) {
  return (std::get<I>(a) == std::get<I>(b));
}

// this is the main routine
template<std::size_t I = 0,
  typename TupleA,
  typename TupleB,
  typename = std::enable_if_t<std::tuple_size<TupleA>::value ==
                                std::tuple_size<TupleB>::value &&
                              (I < std::tuple_size<TupleA>::value - 1) &&
                              std::tuple_size<TupleA>::value >= 2>>
bool
equal_to(const TupleA & a, const TupleB & b) {
  if(std::get<I>(a) != std::get<I>(b))
    return false;
  else
    return equal_to<I + 1>(a, b);
}


// this routine terminates the chain
template<std::size_t I = 0,
  typename TupleA,
  std::enable_if_t<I == std::tuple_size<TupleA>::value - 1> * = nullptr>
std::ostream &
print(std::ostream & output, const TupleA & a, const char *) {
  output << std::get<I>(a);
  return output;
}

// the main calling routine
template<std::size_t I = 0,
  typename TupleA,
  typename = std::enable_if_t<(I < std::tuple_size<TupleA>::value - 1) &&
                              std::tuple_size<TupleA>::value >= 2>>
std::ostream &
print(std::ostream & output, const TupleA & a, const char * sep) {
  output << std::get<I>(a) << sep;
  return print<I + 1>(output, a, sep);
}

} // namespace detail


template<typename T>
struct lexical_comparison {};

template<typename... Args>
struct lexical_comparison<std::tuple<Args...>> {
  using value_type = typename std::tuple<Args...>;
  bool operator()(const value_type & a, const value_type & b) const {
    return detail::less_than(a, b);
  }
};


template<typename T, typename Compare>
class simple_id_t
{};

template<template<typename> class Compare, typename... Args>
class simple_id_t<std::tuple<Args...>, Compare<std::tuple<Args...>>>
{

  //===========================================================================
  // Private data members
  //===========================================================================

  using value_type = std::tuple<Args...>;

  value_type data_;

  static constexpr auto length_ = sizeof...(Args);

public:
  //===========================================================================
  // Public constructors
  //===========================================================================

  simple_id_t() = default;

  simple_id_t(const simple_id_t &) = default;

  simple_id_t(const value_type & data) : data_{data} {}

  template<typename... Ts,
    typename = std::enable_if_t<sizeof...(Ts) == sizeof...(Args)>>
  simple_id_t(Ts &&... ts) : data_{std::make_tuple(std::forward<Ts>(ts)...)} {}

  static constexpr auto size() noexcept {
    return length_;
  }

  friend std::ostream & operator<<(std::ostream & output,
    const simple_id_t & id) {
    detail::print(output, id.data_, ", ");
    return output;
  }

  bool operator==(const simple_id_t & id) const {
    return detail::equal_to(data_, id.data_);
  }

  bool operator<(const simple_id_t & id) const {
    return Compare<value_type>{}(data_, id.data_);
  }

}; // simple_id

} // namespace util
} // namespace flecsi