src/main.h

   1 #ifndef ALURE_MAIN_H
   2 #define ALURE_MAIN_H
   3
   4 #include "alure2.h"
   5
   6
   7 #ifdef __GNUC__
   8 #define LIKELY(x) __builtin_expect(static_cast<bool>(x), true)
   9 #define UNLIKELY(x) __builtin_expect(static_cast<bool>(x), false)
  10 #else
  11 #define LIKELY(x) static_cast<bool>(x)
  12 #define UNLIKELY(x) static_cast<bool>(x)
  13 #endif
  14
  15
  16 #define DECL_THUNK0(ret, C, Name, cv) \
  17 ret C::Name() cv { return pImpl->Name(); }
  18 #define DECL_THUNK1(ret, C, Name, cv, T1)                                     \
  19 ret C::Name(T1 a) cv                                                          \
  20 {                                                                             \
  21     using _t1 = T1;                                                           \
  22     return pImpl->Name(std::forward<_t1&&>(a));                               \
  23 }
  24 #define DECL_THUNK2(ret, C, Name, cv, T1, T2)                                 \
  25 ret C::Name(T1 a, T2 b) cv                                                    \
  26 {                                                                             \
  27     using _t1 = T1; using _t2 = T2;                                           \
  28     return pImpl->Name(std::forward<_t1&&>(a), std::forward<_t2&&>(b));       \
  29 }
  30 #define DECL_THUNK3(ret, C, Name, cv, T1, T2, T3)                             \
  31 ret C::Name(T1 a, T2 b, T3 c) cv                                              \
  32 {                                                                             \
  33     using _t1 = T1; using _t2 = T2; using _t3 = T3;                           \
  34     return pImpl->Name(std::forward<_t1&&>(a), std::forward<_t2&&>(b),        \
  35                        std::forward<_t3&&>(c));                               \
  36 }
  37 #define DECL_THUNK6(ret, C, Name, cv, T1, T2, T3, T4, T5, T6)                 \
  38 ret C::Name(T1 a, T2 b, T3 c, T4 d, T5 e, T6 f) cv                            \
  39 {                                                                             \
  40     using _t1 = T1; using _t2 = T2; using _t3 = T3;                           \
  41     using _t4 = T4; using _t5 = T5; using _t6 = T6;                           \
  42     return pImpl->Name(std::forward<_t1&&>(a), std::forward<_t2&&>(b),        \
  43                        std::forward<_t3&&>(c), std::forward<_t4&&>(d),        \
  44                        std::forward<_t5&&>(e), std::forward<_t6&&>(f));       \
  45 }
  46
  47
  48 namespace alure {
  49
  50 template<size_t N>
  51 struct Bitfield {
  52 private:
  53     std::array<uint8_t,(N+7)/8> mElems;
  54
  55 public:
  56     bool operator[](size_t i) const { return mElems[i/8] & (1<<(i%8)); }
  57
  58     void clear() { std::fill(mElems.begin(), mElems.end(), 0); }
  59     void set(size_t i) { mElems[i/8] |= 1<<(i%8); }
  60 };
  61
  62 } // namespace alure
  63
  64 #endif /* ALURE_MAIN_H */