38 #include <initializer_list>
54 # pragma warning(disable:4200)
55 # pragma warning(disable:4800)
57 #define HB_MARK_AS_FLAG_T(T) \
59 static inline constexpr T operator | (T l, T r) { return T ((unsigned) l | (unsigned) r); } \
60 static inline constexpr T operator & (T l, T r) { return T ((unsigned) l & (unsigned) r); } \
61 static inline constexpr T operator ^ (T l, T r) { return T ((unsigned) l ^ (unsigned) r); } \
62 static inline constexpr T operator ~ (T r) { return T (~(unsigned int) r); } \
63 static inline T& operator |= (T &l, T r) { l = l | r; return l; } \
64 static inline T& operator &= (T& l, T r) { l = l & r; return l; } \
65 static inline T& operator ^= (T& l, T r) { l = l ^ r; return l; } \
67 static_assert (true, "")
73 #define FLAG(x) (static_assert_expr ((unsigned)(x) < 32) + (((uint32_t) 1U) << (unsigned)(x)))
74 #define FLAG_UNSAFE(x) ((unsigned)(x) < 32 ? (((uint32_t) 1U) << (unsigned)(x)) : 0)
75 #define FLAG_RANGE(x,y) (static_assert_expr ((x) < (y)) + FLAG(y+1) - FLAG(x))
76 #define FLAG64(x) (static_assert_expr ((unsigned)(x) < 64) + (((uint64_t) 1ULL) << (unsigned)(x)))
77 #define FLAG64_UNSAFE(x) ((unsigned)(x) < 64 ? (((uint64_t) 1ULL) << (unsigned)(x)) : 0)
85 static inline constexpr uint16_t hb_uint16_swap (uint16_t
v)
86 {
return (
v >> 8) | (
v << 8); }
87 static inline constexpr uint32_t hb_uint32_swap (uint32_t
v)
88 {
return (hb_uint16_swap (
v) << 16) | hb_uint16_swap (
v >> 16); }
90 template <
typename Type,
int Bytes = sizeof (Type)>
92 template <
typename Type>
98 constexpr
operator Type ()
const {
return v; }
101 template <
typename Type>
107 uint8_t ((
V ) & 0xFF)} {}
110 constexpr
operator Type ()
const
112 #if ((defined(__GNUC__) && __GNUC__ >= 5) || defined(__clang__)) && \
113 defined(__BYTE_ORDER) && \
114 (__BYTE_ORDER == __LITTLE_ENDIAN || __BYTE_ORDER == __BIG_ENDIAN)
117 #if __BYTE_ORDER == __LITTLE_ENDIAN
118 return __builtin_bswap16 (((packed_uint16_t *)
this)->
v);
120 return ((packed_uint16_t *)
this)->v;
127 private: uint8_t
v[2];
129 template <
typename Type>
136 uint8_t ((
V >> 8) & 0xFF),
137 uint8_t ((
V ) & 0xFF)} {}
139 constexpr
operator Type ()
const {
return (
v[0] << 16)
142 private: uint8_t
v[3];
144 template <
typename Type>
150 uint8_t ((
V >> 16) & 0xFF),
151 uint8_t ((
V >> 8) & 0xFF),
152 uint8_t ((
V ) & 0xFF)} {}
153 constexpr
operator Type ()
const {
return (
v[0] << 24)
157 private: uint8_t
v[4];
164 _hb_roundf (
float x) {
return floorf (
x + .5f); }
165 #define roundf(x) _hb_roundf(x)
170 #define HB_CODEPOINT_ENCODE3(x,y,z) (((uint64_t) (x) << 42) | ((uint64_t) (y) << 21) | (uint64_t) (z))
171 #define HB_CODEPOINT_DECODE3_1(v) ((hb_codepoint_t) ((v) >> 42))
172 #define HB_CODEPOINT_DECODE3_2(v) ((hb_codepoint_t) ((v) >> 21) & 0x1FFFFFu)
173 #define HB_CODEPOINT_DECODE3_3(v) ((hb_codepoint_t) (v) & 0x1FFFFFu)
176 #define HB_CODEPOINT_ENCODE3_11_7_14(x,y,z) (((uint32_t) ((x) & 0x07FFu) << 21) | (((uint32_t) (y) & 0x007Fu) << 14) | (uint32_t) ((z) & 0x3FFFu))
177 #define HB_CODEPOINT_DECODE3_11_7_14_1(v) ((hb_codepoint_t) ((v) >> 21))
178 #define HB_CODEPOINT_DECODE3_11_7_14_2(v) ((hb_codepoint_t) (((v) >> 14) & 0x007Fu) | 0x0300)
179 #define HB_CODEPOINT_DECODE3_11_7_14_3(v) ((hb_codepoint_t) (v) & 0x3FFFu)
185 template <
typename T> constexpr
auto
192 template <
typename T> constexpr
T&
209 template <
typename T> constexpr
bool
214 template <
typename T>
216 T hb_coerce (
const T v) {
return v; }
217 template <
typename T,
typename V,
220 T hb_coerce (
const V v) {
return *
v; }
226 template <
typename T> constexpr
auto
229 template <typename
T> constexpr
auto
232 template <typename
T,
237 (uint32_t)
v * 2654435761
u
242 template <typename
T> constexpr
auto
253 template <
typename Appl,
typename T,
typename ...Ts>
auto
255 ((hb_deref (std::forward<T> (
v)).*std::forward<Appl> (
a)) (std::forward<Ts> (ds)...))
258 template <
typename Appl,
typename T>
auto
260 ((hb_deref (std::forward<T> (
v))).*std::forward<Appl> (
a))
263 template <
typename Appl,
typename ...Ts>
auto
265 (hb_deref (std::forward<Appl> (
a)) (std::forward<Ts> (ds)...))
269 template <
typename Appl,
typename ...Ts>
auto
272 impl (std::forward<Appl> (
a),
274 std::forward<Ts> (ds)...)
279 template <
unsigned Pos,
typename Appl,
typename V>
284 static_assert (
Pos > 0,
"");
286 template <
typename ...Ts,
293 return hb_invoke (std::forward<Appl> (
a),
295 std::forward<Ts> (ds)...);
297 template <
typename T0,
typename ...Ts,
305 return hb_invoke (std::forward<Appl> (
a),
306 std::forward<T0> (d0),
308 std::forward<Ts> (ds)...);
315 template <
unsigned Pos=1,
typename Appl,
typename V>
339 #define HB_PARTIALIZE(Pos) \
340 template <typename _T> \
341 decltype(auto) operator () (_T&& _v) const \
342 { return hb_partial<Pos> (this, std::forward<_T> (_v)); } \
343 static_assert (true, "")
346 #define HB_PARTIALIZE(Pos) \
347 template <typename _T> \
348 auto operator () (_T&& _v) const HB_AUTO_RETURN \
349 (hb_partial<Pos> (+this, std::forward<_T> (_v))) \
350 static_assert (true, "")
358 template <
typename Pred,
typename Val>
auto
361 hb_deref (std::forward<Pred> (
p)).has (std::forward<Val> (
v))
364 template <
typename Pred,
typename Val>
auto
367 hb_invoke (std::forward<Pred> (
p),
368 std::forward<Val> (
v))
373 template <
typename Pred,
typename Val>
auto
375 impl (std::forward<Pred> (
p),
376 std::forward<Val> (
v),
386 template <
typename Pred,
typename Val>
auto
389 hb_has (std::forward<Pred> (
p),
390 std::forward<Val> (
v))
393 template <
typename Pred,
typename Val>
auto
396 std::forward<Pred> (
p) == std::forward<Val> (
v)
401 template <
typename Pred,
typename Val>
auto
403 impl (std::forward<Pred> (
p),
404 std::forward<Val> (
v),
414 template <
typename Proj,
typename Val>
auto
417 hb_deref (std::forward<Proj> (
f)).
get (std::forward<Val> (
v))
420 template <
typename Proj,
typename Val>
auto
423 hb_invoke (std::forward<Proj> (
f),
424 std::forward<Val> (
v))
427 template <
typename Proj,
typename Val>
auto
430 std::forward<Proj> (
f)[std::forward<Val> (
v)]
435 template <
typename Proj,
typename Val>
auto
438 impl (std::forward<Proj> (
f),
439 std::forward<Val> (
v),
449 template <
typename T1,
typename T2>
auto
452 std::forward<T2> (
v2).cmp (std::forward<T1> (
v1)) == 0
455 template <typename
T1, typename
T2>
auto
461 template <typename
T1, typename
T2>
auto
467 template <typename
T1, typename
T2>
auto
475 template <typename
T1, typename
T2>
auto
486 template <typename
T1, typename
T2>
493 template <
typename U1 =
T1,
typename U2 =
T2,
499 template <
typename Q1,
typename Q2,
517 #define hb_pair_t(T1,T2) hb_pair_t<T1, T2>
523 template <
typename Pair> constexpr
typename Pair::first_t
530 template <
typename Pair> constexpr
typename Pair::second_t
541 template <
typename T,
typename T2> constexpr
auto
543 (
a <=
b ? std::forward<T> (
a) : std::forward<T2> (
b))
548 template <
typename T,
typename T2> constexpr
auto
550 (
a >=
b ? std::forward<T> (
a) : std::forward<T2> (
b))
555 template <
typename T,
typename T2,
typename T3> constexpr
auto
557 (hb_min (hb_max (std::forward<T> (
x), std::forward<T2> (min)), std::forward<T3> (max)))
563 template <
typename T>
void
577 template <
typename T>
578 static inline unsigned int
581 #if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)
582 if (
sizeof (
T) <=
sizeof (
unsigned int))
583 return __builtin_popcount (
v);
585 if (
sizeof (
T) <=
sizeof (
unsigned long))
586 return __builtin_popcountl (
v);
588 if (
sizeof (
T) <=
sizeof (
unsigned long long))
589 return __builtin_popcountll (
v);
596 y = (
v >> 1) &033333333333;
597 y =
v -
y - ((
y >>1) & 033333333333);
598 return (((
y + (
y >> 3)) & 030707070707) % 077);
603 unsigned int shift = 32;
604 return hb_popcount<uint32_t> ((uint32_t)
v) + hb_popcount ((uint32_t) (
v >>
shift));
607 if (
sizeof (
T) == 16)
609 unsigned int shift = 64;
610 return hb_popcount<uint64_t> ((uint64_t)
v) + hb_popcount ((uint64_t) (
v >>
shift));
618 template <
typename T>
619 static inline unsigned int
624 #if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)
625 if (
sizeof (
T) <=
sizeof (
unsigned int))
626 return sizeof (
unsigned int) * 8 - __builtin_clz (
v);
628 if (
sizeof (
T) <=
sizeof (
unsigned long))
629 return sizeof (
unsigned long) * 8 - __builtin_clzl (
v);
631 if (
sizeof (
T) <=
sizeof (
unsigned long long))
632 return sizeof (
unsigned long long) * 8 - __builtin_clzll (
v);
635 #if (defined(_MSC_VER) && _MSC_VER >= 1500) || (defined(__MINGW32__) && (__GNUC__ < 4))
636 if (
sizeof (
T) <=
sizeof (
unsigned int))
639 _BitScanReverse (&where,
v);
646 _BitScanReverse64 (&where,
v);
655 const unsigned int b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
656 const unsigned int S[] = {1, 2, 4, 8, 16};
658 for (
int i = 4;
i >= 0;
i--)
669 const uint64_t
b[] = {0x2ULL, 0xCULL, 0xF0ULL, 0xFF00ULL, 0xFFFF0000ULL, 0xFFFFFFFF00000000ULL};
670 const unsigned int S[] = {1, 2, 4, 8, 16, 32};
672 for (
int i = 5;
i >= 0;
i--)
680 if (
sizeof (
T) == 16)
682 unsigned int shift = 64;
683 return (
v >>
shift) ? hb_bit_storage<uint64_t> ((uint64_t) (
v >>
shift)) +
shift :
684 hb_bit_storage<uint64_t> ((uint64_t)
v);
692 template <
typename T>
693 static inline unsigned int
698 #if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)
699 if (
sizeof (
T) <=
sizeof (
unsigned int))
700 return __builtin_ctz (
v);
702 if (
sizeof (
T) <=
sizeof (
unsigned long))
703 return __builtin_ctzl (
v);
705 if (
sizeof (
T) <=
sizeof (
unsigned long long))
706 return __builtin_ctzll (
v);
709 #if (defined(_MSC_VER) && _MSC_VER >= 1500) || (defined(__MINGW32__) && (__GNUC__ < 4))
710 if (
sizeof (
T) <=
sizeof (
unsigned int))
713 _BitScanForward (&where,
v);
720 _BitScanForward64 (&where,
v);
732 if (
v & 0x0000FFFF)
c -= 16;
733 if (
v & 0x00FF00FF)
c -= 8;
734 if (
v & 0x0F0F0F0F)
c -= 4;
735 if (
v & 0x33333333)
c -= 2;
736 if (
v & 0x55555555)
c -= 1;
743 v &= - (int64_t) (
v);
745 if (
v & 0x00000000FFFFFFFFULL)
c -= 32;
746 if (
v & 0x0000FFFF0000FFFFULL)
c -= 16;
747 if (
v & 0x00FF00FF00FF00FFULL)
c -= 8;
748 if (
v & 0x0F0F0F0F0F0F0F0FULL)
c -= 4;
749 if (
v & 0x3333333333333333ULL)
c -= 2;
750 if (
v & 0x5555555555555555ULL)
c -= 1;
753 if (
sizeof (
T) == 16)
755 unsigned int shift = 64;
756 return (uint64_t)
v ? hb_bit_storage<uint64_t> ((uint64_t)
v) :
757 hb_bit_storage<uint64_t> ((uint64_t) (
v >>
shift)) +
shift;
770 static inline bool ISALPHA (
unsigned char c)
771 {
return (
c >=
'a' &&
c <=
'z') || (
c >=
'A' &&
c <=
'Z'); }
772 static inline bool ISALNUM (
unsigned char c)
773 {
return (
c >=
'a' &&
c <=
'z') || (
c >=
'A' &&
c <=
'Z') || (
c >=
'0' &&
c <=
'9'); }
774 static inline bool ISSPACE (
unsigned char c)
775 {
return c ==
' ' ||
c ==
'\f'||
c ==
'\n'||
c ==
'\r'||
c ==
'\t'||
c ==
'\v'; }
776 static inline unsigned char TOUPPER (
unsigned char c)
777 {
return (
c >=
'a' &&
c <=
'z') ?
c -
'a' +
'A' :
c; }
778 static inline unsigned char TOLOWER (
unsigned char c)
779 {
return (
c >=
'A' &&
c <=
'Z') ?
c -
'A' +
'a' :
c; }
780 static inline bool ISHEX (
unsigned char c)
781 {
return (
c >=
'0' &&
c <=
'9') || (
c >=
'a' &&
c <=
'f') || (
c >=
'A' &&
c <=
'F'); }
782 static inline unsigned char TOHEX (uint8_t
c)
783 {
return (
c & 0xF) <= 9 ? (
c & 0xF) +
'0' : (
c & 0xF) +
'a' - 10; }
784 static inline uint8_t FROMHEX (
unsigned char c)
785 {
return (
c >=
'0' &&
c <=
'9') ?
c -
'0' : TOLOWER (
c) -
'a' + 10; }
787 static inline unsigned int DIV_CEIL (
const unsigned int a,
unsigned int b)
788 {
return (
a + (
b - 1)) /
b; }
792 template <
typename Type,
unsigned int n>
795 #define ARRAY_LENGTH_CONST(__array) ((signed int) (sizeof (__array) / sizeof (__array[0])))
799 hb_memcpy (
void *__restrict
dst,
const void *__restrict
src,
size_t len)
807 hb_memcmp (
const void *
a,
const void *
b,
unsigned int len)
813 return memcmp (
a,
b,
len);
817 hb_memset (
void *
s,
int c,
unsigned int n)
821 return memset (
s,
c,
n);
824 static inline unsigned int
825 hb_ceil_to_4 (
unsigned int v)
827 return ((
v - 1) | 3) + 1;
830 template <
typename T>
static inline bool
831 hb_in_range (
T u,
T lo,
T hi)
837 return (
T)(
u - lo) <= (
T)(hi - lo);
839 template <
typename T>
static inline bool
840 hb_in_ranges (
T u,
T lo1,
T hi1,
T lo2,
T hi2)
842 return hb_in_range (
u, lo1, hi1) || hb_in_range (
u, lo2, hi2);
844 template <
typename T>
static inline bool
845 hb_in_ranges (
T u,
T lo1,
T hi1,
T lo2,
T hi2,
T lo3,
T hi3)
847 return hb_in_range (
u, lo1, hi1) || hb_in_range (
u, lo2, hi2) || hb_in_range (
u, lo3, hi3);
857 hb_unsigned_mul_overflows (
unsigned int count,
unsigned int size)
867 template <
typename K,
typename V,
typename ...Ts>
869 _hb_cmp_method (
const void *pkey,
const void *pval, Ts... ds)
871 const K&
key = * (
const K*) pkey;
872 const V&
val = * (
const V*) pval;
874 return val.cmp (
key, ds...);
877 template <
typename V,
typename K,
typename ...Ts>
879 hb_bsearch_impl (
unsigned *
pos,
882 int (*compar)(
const void *_key,
const void *_item, Ts... _ds),
887 int min = 0, max = (int) nmemb - 1;
890 int mid = ((
unsigned int) min + (
unsigned int) max) / 2;
891 #pragma GCC diagnostic push
892 #pragma GCC diagnostic ignored "-Wcast-align"
894 #pragma GCC diagnostic pop
895 int c = compar ((
const void *) std::addressof (
key), (
const void *)
p, ds...);
910 template <
typename V,
typename K>
913 size_t nmemb,
size_t stride =
sizeof (
V),
914 int (*compar)(
const void *_key,
const void *_item) = _hb_cmp_method<K, V>)
917 #pragma GCC diagnostic push
918 #pragma GCC diagnostic ignored "-Wcast-align"
921 #pragma GCC diagnostic pop
923 template <
typename V,
typename K,
typename ...Ts>
926 size_t nmemb,
size_t stride,
927 int (*compar)(
const void *_key,
const void *_item, Ts... _ds),
931 #pragma GCC diagnostic push
932 #pragma GCC diagnostic ignored "-Wcast-align"
935 #pragma GCC diagnostic pop
959 #define SORT_R_SWAP(a,b,tmp) ((tmp) = (a), (a) = (b), (b) = (tmp))
963 static inline void sort_r_swap(
char *__restrict
a,
char *__restrict
b,
966 char tmp, *
end =
a+
w;
973 template <
typename ...Ts>
974 static inline int sort_r_cmpswap(
char *__restrict
a,
975 char *__restrict
b,
size_t w,
976 int (*compar)(
const void *_a,
981 if(compar(
a,
b, ds...) > 0) {
982 sort_r_swap(
a,
b,
w);
996 static inline void sort_r_swap_blocks(
char *ptr,
size_t na,
size_t nb)
998 if(na > 0 && nb > 0) {
999 if(na > nb) { sort_r_swap(ptr, ptr+na, nb); }
1000 else { sort_r_swap(ptr, ptr+nb, na); }
1006 template <
typename ...Ts>
1007 static inline void sort_r_simple(
void *
base,
size_t nel,
size_t w,
1008 int (*compar)(
const void *_a,
1022 for(pj =
pi; pj >
b && sort_r_cmpswap(pj-
w,pj,
w,compar,ds...); pj -=
w) {}
1030 char *pl, *ple, *pr, *pre, *pivot;
1031 char *last =
b+
w*(nel-1), *tmp;
1045 if(compar(
l[1],
l[2],ds...) > 0) {
1051 if(
l[1] != last) { sort_r_swap(
l[1], last,
w); }
1080 for(; pl < pr; pl +=
w) {
1081 cmp = compar(pl, pivot, ds...);
1082 if(cmp > 0) {
break; }
1084 if(ple < pl) { sort_r_swap(ple, pl,
w); }
1089 if(pl >= pr) {
break; }
1094 cmp = compar(pr, pivot, ds...);
1097 if(pr < pre) { sort_r_swap(pr, pre,
w); }
1100 if(pl < pr) { sort_r_swap(pl, pr,
w); }
1115 sort_r_swap_blocks(
b, ple-
b, pl-ple);
1116 sort_r_swap_blocks(pr, pre-pr,
end-pre);
1121 sort_r_simple(
b, (pl-ple)/
w,
w, compar, ds...);
1122 sort_r_simple(
end-(pre-pr), (pre-pr)/
w,
w, compar, ds...);
1127 hb_qsort (
void *
base,
size_t nel,
size_t width,
1128 int (*compar)(
const void *_a,
const void *_b))
1130 #if defined(__OPTIMIZE_SIZE__) && !defined(HB_USE_INTERNAL_QSORT)
1133 sort_r_simple (
base, nel,
width, compar);
1138 hb_qsort (
void *
base,
size_t nel,
size_t width,
1139 int (*compar)(
const void *_a,
const void *_b,
void *_arg),
1142 #ifdef HAVE_GNU_QSORT_R
1150 template <
typename T,
typename T2,
typename T3>
static inline void
1151 hb_stable_sort (
T *
array,
unsigned int len,
int(*compar)(
const T2 *,
const T2 *),
T3 *array2)
1153 for (
unsigned int i = 1;
i <
len;
i++)
1169 memmove (&array2[
j + 1], &array2[
j], (
i -
j) *
sizeof (
T3));
1175 template <
typename T>
static inline void
1176 hb_stable_sort (
T *
array,
unsigned int len,
int(*compar)(
const T *,
const T *))
1178 hb_stable_sort (
array,
len, compar, (
int *)
nullptr);
1199 template <
typename T> constexpr
auto
1205 template <
typename T> constexpr
auto
1211 template <
typename T> constexpr
auto
1217 template <
typename T> constexpr
auto
1223 template <
typename T> constexpr
auto
1229 template <
typename T> constexpr
auto
1235 template <
typename T> constexpr
auto
1241 template <
typename T> constexpr
auto
1248 template <
typename T,
typename T2> constexpr
auto
1254 template <
typename T,
typename T2> constexpr
auto
1260 template <
typename T,
typename T2> constexpr
auto
1266 template <
typename T,
typename T2> constexpr
auto
1272 template <
typename T,
typename T2> constexpr
auto
1278 template <
typename T,
typename T2> constexpr
auto
1284 template <
typename T> constexpr
auto
1290 template <
typename T> constexpr
auto
1296 template <
typename T> constexpr
auto
1302 template <
typename T> constexpr
auto
1312 template <
typename elt_t,
unsigned int byte_size>
1318 void clear (
unsigned char v = 0) { memset (
this,
v,
sizeof (*
this)); }
1320 template <
typename Op>
1328 template <
typename Op>
1337 {
return process (hb_bitwise_or,
o); }
1339 {
return process (hb_bitwise_and,
o); }
1341 {
return process (hb_bitwise_xor,
o); }
1343 {
return process (hb_bitwise_neg); }
1346 static_assert (0 == byte_size %
sizeof (elt_t),
"");
1347 elt_t
v[byte_size /
sizeof (elt_t)];
small capitals from c petite p scientific f u
small capitals from c petite p scientific i
[1]
bool operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept
template< typename Enum > bool operator!=(Enum lhs, QFlags< Enum > rhs)
template< typename Enum > bool operator==(Enum lhs, QFlags< Enum > rhs)
bool operator<=(const QUuid &lhs, const QUuid &rhs)
bool operator>=(const QUuid &lhs, const QUuid &rhs)
QHash< int, QWidget * > hash
[35multi]
auto hb_partial(Appl &&a, V &&v) HB_AUTO_RETURN((hb_partial_t< Pos
struct hb_partial_t HB_FUNCOBJ
#define SORT_R_SWAP(a, b, tmp)
#define HB_PARTIALIZE(Pos)
constexpr T & operator()(T &v) const
auto it unsigned count const
bool hb_parse_uint(const char **pp, const char *end, unsigned *pv, bool whole_buffer, int base)
void swap(SimpleVector< T > &v1, SimpleVector< T > &v2)
void *PRIV() memmove(void *d, const void *s, size_t n)
set set set set set set set macro pixldst1 op
EGLOutputLayerEXT EGLint EGLAttrib value
constexpr bool operator>(const QFixed &f, int i)
GLint GLfloat GLfloat GLfloat v2
GLboolean GLboolean GLboolean b
GLsizei const GLfloat * v
[13]
GLint GLint GLint GLint GLint x
[0]
GLfloat GLfloat GLfloat w
[0]
GLboolean GLboolean GLboolean GLboolean a
[7]
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLenum GLenum GLsizei count
const void GLsizei GLsizei stride
GLuint GLenum GLsizei GLsizei GLint GLint GLboolean packed
HB_BEGIN_DECLS typedef int hb_bool_t
QTextStream out(stdout)
[7]
http get(QUrl::toPercentEncoding("/index.html"))
hb_pair_t< T1, T2 > pair_t
hb_pair_t< T1, T2 > reverse() const
hb_partial_t(Appl a, V v)
auto operator()(Ts &&...ds) -> decltype(hb_invoke(hb_declval(Appl), hb_declval(V), hb_declval(Ts)...))
elt_t & operator[](unsigned int i)
hb_vector_size_t operator|(const hb_vector_size_t &o) const
hb_vector_size_t operator^(const hb_vector_size_t &o) const
hb_vector_size_t operator~() const
hb_vector_size_t operator&(const hb_vector_size_t &o) const
void clear(unsigned char v=0)
hb_vector_size_t process(const Op &op, const hb_vector_size_t &o) const
hb_vector_size_t process(const Op &op) const