types.h

#ifndef ADIAR_TYPES_H
#define ADIAR_TYPES_H
 
#include <optional>
#include <utility>
 
namespace adiar
{
  enum class assignment : signed char
  {
    False = 0,
    True = 1,
    None = -1
  };
 
  enum class replace_type : signed char
  {
    Auto = -1,
 
    Non_Monotone = 8, // TODO
 
    /* (Combination of 'Jump_Up' and 'Jump_Down'): Variable remapping which only swaps one pair of
                                                   variables in separate blocks.
    */
    // Swap = 7, // TODO
 
    /* (Single-sweep version of 'Non_Monotone'): Variable remapping, only moving some variables up
                                                 without crossing other variables that are moving.
    */
    // Jump_Up = 6, // TODO
 
    /* (Single-sweep version of 'Non_Monotone'): Variable remapping, only moving some variables down
                                                 without crossing other variables that are moving.
    */
    // Jump_Down = 5, // TODO
 
    /* Variable remapping, only swapping variables that are adjacent to each other.
     */
    // Swap_Adjacent = 4, // TODO
 
    Monotone = 3,
 
    /* (faster version of 'Monotone'): `m(x) = ax + b` for some integers `a` and `b`. */
    // Affine = 2, // TODO: Is there a use-case where this type of on-the-fly remapping is needed?
 
    Shift = 1,
 
    Identity = 0
  };
 
  template <typename T1, typename T2>
  using pair = std::pair<T1, T2>;
 
  template <typename T1, typename T2>
  constexpr pair<T1, T2>
  make_pair(const T1& t1, const T2& t2)
  {
    return std::make_pair(t1, t2);
  }
 
  /*
  template<typename T1, typename T2>
  constexpr pair<T1, T2>
  make_pair(T1 &&t1, T2 &&t2)
  { return std::make_pair(std::move(t1), std::move(t2)); }
  */
 
  template <typename T>
  using optional = std::optional<T>;
 
  template <typename T>
  constexpr optional<T>
  make_optional()
  {
    return optional<T>();
  }
 
  template <typename T>
  constexpr optional<T>
  make_optional(const T& t)
  {
    return std::make_optional(t);
  }
 
  /*
  template<typename T>
  constexpr optional<T>
  make_optional(T &&t)
  { return std::make_optional(std::move(t)); }
  */
}
 
#endif // ADIAR_TYPES_H