types

Go to the documentation of this file.

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
 
 
#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:
    typedef UNDERLYING value_type;
    typedef BITS_ENUM bits_enum_type;
    typedef Flags<BITS_ENUM, UNDERLYING> type;
 
  private:
    value_type _v;
    explicit Flags(value_type v) : _v(v) {}
 
  public:
    enum None_type { None  };
 
    Flags(None_type) : _v(0) {}
 
    Flags() : _v(0) {}
 
    Flags(BITS_ENUM e) : _v((value_type{1}) << e) {}
 
    static type from_raw(value_type v) { return type(v); }
 
    explicit operator bool () const
    { return _v != 0; }
 
    bool operator ! () const { return _v == 0; }
 
    friend type operator | (type lhs, type rhs)
    { return type(lhs._v | rhs._v); }
 
    friend type operator | (type lhs, bits_enum_type rhs)
    { return lhs | type(rhs); }
 
    friend type operator & (type lhs, type rhs)
    { return type(lhs._v & rhs._v); }
 
    friend type operator & (type lhs, bits_enum_type rhs)
    { return lhs & type(rhs); }
 
    type &operator |= (type rhs) { _v |= rhs._v; return *this; }
    type &operator |= (bits_enum_type rhs) { return operator |= (type(rhs)); }
 
    type &operator &= (type rhs) { _v &= rhs._v; return *this; }
    type &operator &= (bits_enum_type rhs) { return operator &= (type(rhs)); }
 
    type operator ~ () const { return type(~_v); }
 
    type &clear(bits_enum_type flag) { return operator &= (~type(flag)); }
 
    value_type as_value() const { return _v; }
  };
 
  template<unsigned SIZE, bool = true> struct Int_for_size;
 
  template<> struct Int_for_size<sizeof(unsigned char), true>
  { typedef unsigned char type; };
 
  template<> struct Int_for_size<sizeof(unsigned short),
                                 (sizeof(unsigned short) > sizeof(unsigned char))>
  { typedef unsigned short type; };
 
  template<> struct Int_for_size<sizeof(unsigned),
                                 (sizeof(unsigned) > sizeof(unsigned short))>
  { typedef unsigned type; };
 
  template<> struct Int_for_size<sizeof(unsigned long),
                                 (sizeof(unsigned long) > sizeof(unsigned))>
  { typedef unsigned long type; };
 
  template<> struct Int_for_size<sizeof(unsigned long long),
                                 (sizeof(unsigned long long) > sizeof(unsigned long))>
  { typedef unsigned long long type; };
 
  template<typename T> struct Int_for_type
  {
    typedef typename Int_for_size<sizeof(T)>::type type;
  };
 
#define L4_TYPES_FLAGS_OPS_DEF(T)                                            \
    friend constexpr T operator ~ (T f)                                      \
    {                                                                        \
      return T(~static_cast<typename L4::Types::Int_for_type<T>::type>(f));  \
    }                                                                        \
                                                                             \
    friend constexpr T operator | (T l, T r)                                 \
    {                                                                        \
      return T(static_cast<typename L4::Types::Int_for_type<T>::type>(l)     \
               | static_cast<typename L4::Types::Int_for_type<T>::type>(r)); \
    }                                                                        \
                                                                             \
    friend constexpr T operator & (T l, T r)                                 \
    {                                                                        \
      return T(static_cast<typename L4::Types::Int_for_type<T>::type>(l)     \
               & static_cast<typename L4::Types::Int_for_type<T>::type>(r)); \
    }
 
  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 bool operator == (DT l, DT r)
    { return l.raw == r.raw; }
 
    friend constexpr bool operator != (DT l, DT r)
    { return l.raw != r.raw; }
 
    DT operator |= (DT r)
    {
      static_cast<DT *>(this)->raw |= r.raw;
      return *static_cast<DT *>(this);
    }
 
    DT operator &= (DT 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;
    Flags_t() = default;
    explicit constexpr Flags_t(T f) : raw(f) {}
  };
 
 
  template< bool V > struct Bool
  {
    typedef Bool<V> type; 
    enum { value = V };   
  };
 
  struct False : Bool<false> {};
 
  struct True : Bool<true> {};
 
  /*********************/
  template<typename A, typename B>
  struct Same : False {};
 
  template<typename A>
  struct Same<A, A> : True {};
 
  template<bool EXP, typename T = void> struct Enable_if {};
  template<typename T> struct Enable_if<true, T> { typedef T type; };
 
  template<typename T1, typename T2, typename T = void>
  struct Enable_if_same : Enable_if<Same<T1, T2>::value, T> {};
 
  template<typename T> struct Remove_const { typedef T type; };
  template<typename T> struct Remove_const<T const> { typedef T type; };
  template<typename T> struct Remove_volatile { typedef T type; };
  template<typename T> struct Remove_volatile<T volatile> { typedef T type; };
  template<typename T> struct Remove_cv
  { typedef typename Remove_const<typename Remove_volatile<T>::type>::type type; };
 
  template<typename T> struct Remove_pointer { typedef T type; };
  template<typename T> struct Remove_pointer<T*> { typedef T type; };
  template<typename T> struct Remove_reference { typedef T type; };
  template<typename T> struct Remove_reference<T&> { typedef T type; };
  template<typename T> struct Remove_pr { typedef T type; };
  template<typename T> struct Remove_pr<T&> { typedef T type; };
  template<typename T> struct Remove_pr<T*> { typedef T type; };
} // Types
} // L4