types

Go to the documentation of this file.

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */

 
#pragma once
 
// very simple type traits for basic L4 functions, for a more complete set
// use <l4/cxx/type_traits> or the standard <type_traits>.
 
namespace L4 {

namespace Types {

  template<typename BITS_ENUM, typename UNDERLYING = unsigned long>
  class Flags
  {
  public:
    using value_type = UNDERLYING;
    using bits_enum_type = BITS_ENUM;
    using type = Flags<BITS_ENUM, UNDERLYING>;
 
  private:
    value_type _v;
    explicit constexpr Flags(value_type v) noexcept : _v(v) {}
 
  public:
    enum None_type { None  };

    constexpr Flags(None_type) noexcept : _v(0) {}

    constexpr Flags() noexcept : _v(0) {}

    constexpr Flags(BITS_ENUM e) noexcept
    : _v(static_cast<value_type>(1) << e)
    {}

    static constexpr type from_raw(value_type v) noexcept { return type(v); }

    explicit constexpr operator bool () const noexcept
    { return _v != 0; }

    constexpr bool operator ! () const noexcept { return _v == 0; }

    friend constexpr type operator | (type lhs, type rhs) noexcept
    { return type(lhs._v | rhs._v); }

    friend constexpr type operator | (type lhs, bits_enum_type rhs) noexcept
    { return lhs | type(rhs); }

    friend constexpr type operator & (type lhs, type rhs) noexcept
    { return type(lhs._v & rhs._v); }

    friend constexpr type operator & (type lhs, bits_enum_type rhs) noexcept
    { return lhs & type(rhs); }

    constexpr type &operator |= (type rhs) noexcept
    { _v |= rhs._v; return *this; }

    constexpr type &operator |= (bits_enum_type rhs)
    { return operator |= (type(rhs)); }

    constexpr type &operator &= (type rhs) { _v &= rhs._v; return *this; }

    constexpr type &operator &= (bits_enum_type rhs)
    { return operator &= (type(rhs)); }

    constexpr type operator ~ () const noexcept { return type(~_v); }

    constexpr type &clear(bits_enum_type flag) noexcept
    { return operator &= (~type(flag)); }

    constexpr value_type as_value() const noexcept { return _v; }
  };

  template<unsigned SIZE, bool = true> struct Int_for_size;
 
  template<> struct Int_for_size<sizeof(unsigned char), true>
  { using type = unsigned char; };
 
  template<> struct Int_for_size<sizeof(unsigned short),
                                 (sizeof(unsigned short) > sizeof(unsigned char))>
  { using type = unsigned short; };
 
  template<> struct Int_for_size<sizeof(unsigned),
                                 (sizeof(unsigned) > sizeof(unsigned short))>
  { using type = unsigned; };
 
  template<> struct Int_for_size<sizeof(unsigned long),
                                 (sizeof(unsigned long) > sizeof(unsigned))>
  { using type = unsigned long; };
 
  template<> struct Int_for_size<sizeof(unsigned long long),
                                 (sizeof(unsigned long long) > sizeof(unsigned long))>
  { using type = unsigned long long; };

  template<typename T> struct Int_for_type
  {
    using type = typename Int_for_size<sizeof(T)>::type;
  };

  template<typename DT>
  struct Flags_ops_t
  {
    friend constexpr DT operator | (DT l, DT r)
    { return DT(l.raw | r.raw); }

    friend constexpr DT operator & (DT l, DT r)
    { return DT(l.raw & r.raw); }

    friend constexpr DT operator - (DT l, DT r)
    { return DT(l.raw & ~r.raw); }

    friend constexpr bool operator == (DT l, DT r)
    { return l.raw == r.raw; }

    friend constexpr bool operator != (DT l, DT r)
    { return l.raw != r.raw; }

    constexpr DT &operator |= (DT const r)
    {
      static_cast<DT *>(this)->raw |= r.raw;
      return *static_cast<DT *>(this);
    }

    constexpr DT &operator &= (DT const r)
    {
      static_cast<DT *>(this)->raw &= r.raw;
      return *static_cast<DT *>(this);
    }

    constexpr DT &operator -= (DT const r)
    {
      static_cast<DT *>(this)->raw &= ~r.raw;
      return *static_cast<DT *>(this);
    }

    explicit constexpr operator bool () const
    { return static_cast<DT const *>(this)->raw != 0; }

    constexpr DT operator ~ () const
    { return DT(~static_cast<DT const *>(this)->raw); }
  };

  template<typename DT, typename T>
  struct Flags_t : Flags_ops_t<Flags_t<DT, T>>
  {
    T raw = 0;
    constexpr Flags_t() = default;
    constexpr Flags_t(DT f) : raw(static_cast<T>(f)) {}
    explicit constexpr Flags_t(T f) : raw(f) {}

    static constexpr Flags_t None = Flags_t();
  };

  template<typename...> using Void = void;

  template<typename T, typename = void> struct __Add_rvalue_reference_helper
  { using type = T; };

  template<typename T> struct __Add_rvalue_reference_helper<T, Void<T &&>>
  { using type = T &&; };

  template<typename T> struct Add_rvalue_reference
  { using type = typename __Add_rvalue_reference_helper<T>::type; };

  template<typename T> using Add_rvalue_reference_t
    = typename Add_rvalue_reference<T>::type;

  template<typename T> Add_rvalue_reference_t<T> declval() noexcept;

   */
  template< bool V > struct Bool
  {
    using type = Bool<V>; 
    enum { value = V };   
  };

  struct False : Bool<false> {};

  struct True : Bool<true> {};

  template<typename T, T Value>
  struct Integral_constant
  {
    static T const value = Value;
 
    typedef T value_type;
    typedef Integral_constant<T, Value> type;
  };

  template<typename T>
  struct Is_enum : Integral_constant<bool, __is_enum(T)> {};

  template<typename T, bool = Is_enum<T>::value>
  struct __Underlying_type_helper { using type = __underlying_type(T); };

  template<typename T> struct __Underlying_type_helper<T, false> {};

  /// Get an underlying type of an enumeration type.
  template<typename T> struct Underlying_type
    : public __Underlying_type_helper<T> {};

  template<typename T> using Underlying_type_t
    = typename Underlying_type<T>::type;
 
  /*********************/
  template<typename A, typename B>
  struct Same : False {};
 
  template<typename A>
  struct Same<A, A> : True {};
 
  template< typename T1, typename T2 >
  inline constexpr bool Same_v = Same<T1, T2>::value;

  template <typename T, template <typename...> typename Template>
  struct Same_template : False {};
 
  template <template <typename...> typename Template, typename... Args>
  struct Same_template<Template<Args...>, Template> : True {};
 
  template <typename T, template <typename...> typename Template>
  inline constexpr bool Same_template_v = Same_template<T, Template>::value;
 
  template<bool, typename = void> struct Enable_if {};
  template<typename T> struct Enable_if<true, T> { using type = T; };

  template<bool Condition, typename T = void>
    using Enable_if_t = typename Enable_if<Condition, T>::type;
 
  template<typename T1, typename T2, typename T = void>
  struct Enable_if_same : Enable_if<Same_v<T1, T2>, T> {};
 
  template<typename T> struct Remove_const { using type = T; };
  template<typename T> struct Remove_const<T const> { using type = T; };
  template<typename T> using Remove_const_t = typename Remove_const<T>::type;
 
  template<typename T> struct Remove_volatile { using type = T; };
  template<typename T> struct Remove_volatile<T volatile> { using type = T; };
  template<typename T> using Remove_volatile_t = typename Remove_volatile<T>::type;
 
  template<typename T> struct Remove_cv
  { using type = Remove_const_t<Remove_volatile_t<T>>; };
  template<typename T> using Remove_cv_t = typename Remove_cv<T>::type;
 
  template<typename T> struct Remove_pointer { using type = T; };
  template<typename T> struct Remove_pointer<T*> { using type = T; };
  template<typename T> using Remove_pointer_t = typename Remove_pointer<T>::type;
 
  template<typename T> struct Remove_reference { using type = T; };
  template<typename T> struct Remove_reference<T&> { using type = T; };
  template<typename T> using Remove_reference_t = typename Remove_reference<T>::type;
 
  template<typename T> struct Remove_pr { using type = T; };
  template<typename T> struct Remove_pr<T&> { using type = T; };
  template<typename T> struct Remove_pr<T*> { using type = T; };
  template<typename T> using Remove_pr_t = typename Remove_pr<T>::type;
 
  template<typename T>
  constexpr T &&
  forward(Remove_reference_t<T> &t)
  { return static_cast<T &&>(t); }
 
  template<typename T>
  constexpr T &&
  forward(Remove_reference_t<T> &&t)
  { return static_cast<T &&>(t); }
 
  template<typename T>
  constexpr Remove_reference_t<T> &&
  move(T &&t) { return static_cast<Remove_reference_t<T> &&>(t); }
 
  template< typename... > using Void_t = void;
} // Types
 
} // L4

namespace Enum_bitops {
  using namespace L4::Types;

  template<typename, typename = void> struct Has_marker : False {};

  template<typename T>
  struct Has_marker<T, Void<decltype(enum_bitops_enable(declval<T>()))>>
    : True {};

  template<typename T>
  struct Enable
    : Integral_constant<bool, Is_enum<T>::value && Has_marker<T>::value> {};
} // Enum_bitops

inline namespace Enum_bitops_impl {
  template<typename T,
           typename = L4::Types::Enable_if_t<L4::Types::Is_enum<T>::value>>
  constexpr L4::Types::Underlying_type_t<T> to_underlying(T const arg) noexcept
  { return static_cast<L4::Types::Underlying_type_t<T>>(arg); }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T operator ~ (T const a) noexcept
  { return static_cast<T>(~to_underlying(a)); }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T operator & (T l, T r) noexcept
  { return static_cast<T>(to_underlying(l) & to_underlying(r)); }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T &operator &= (T &a, T const b) noexcept
  {
    a = a & b;
    return a;
  }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T operator | (T l, T r) noexcept
  { return static_cast<T>(to_underlying(l) | to_underlying(r)); }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T &operator |= (T &a, T const b) noexcept
  {
    a = a | b;
    return a;
  }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T operator - (T l, T r) noexcept
  { return static_cast<T>(to_underlying(l) & ~to_underlying(r)); }

  template<typename T,
           typename = L4::Types::Enable_if_t<Enum_bitops::Enable<T>::value>>
  constexpr T &operator -= (T &a, T const b) noexcept
  {
    a = a - b;
    return a;
  }
} // Enum_bitops_impl