{
template <typename T> T
operator () (const T& v) const { return v; }
-} HB_FUNCOBJ (hb_identity);
+}
+HB_FUNCOBJ (hb_identity);
struct
{
template <typename T> bool
operator () (const T& v) const { return bool (v); }
-} HB_FUNCOBJ (hb_bool);
+}
+HB_FUNCOBJ (hb_bool);
struct
{
template <typename T> auto
operator () (const T& v) const HB_RETURN (uint32_t, impl (v, hb_prioritize))
-} HB_FUNCOBJ (hb_hash);
+}
+HB_FUNCOBJ (hb_hash);
struct
{
hb_prioritize,
hb_forward<Vals> (vs)...)
)
-} HB_FUNCOBJ (hb_invoke);
+}
+HB_FUNCOBJ (hb_invoke);
struct
{
hb_forward<Val> (v),
hb_prioritize)
)
-} HB_FUNCOBJ (hb_has);
+}
+HB_FUNCOBJ (hb_has);
struct
{
hb_forward<Val> (v),
hb_prioritize)
)
-} HB_FUNCOBJ (hb_get);
+}
+HB_FUNCOBJ (hb_get);
template <typename T1, typename T2>
{
template <typename Pair> auto
operator () (const Pair& pair) const HB_AUTO_RETURN (pair.first)
-} HB_FUNCOBJ (hb_first);
+}
+HB_FUNCOBJ (hb_first);
struct
{
template <typename Pair> auto
operator () (const Pair& pair) const HB_AUTO_RETURN (pair.second)
-} HB_FUNCOBJ (hb_second);
+}
+HB_FUNCOBJ (hb_second);
struct
{
template <typename T, typename T2> auto
operator () (const T& a, const T2& b) const HB_AUTO_RETURN (a <= b ? a : b)
-} HB_FUNCOBJ (hb_min);
+}
+HB_FUNCOBJ (hb_min);
struct
{
template <typename T, typename T2> auto
operator () (const T& a, const T2& b) const HB_AUTO_RETURN (a >= b ? a : b)
-} HB_FUNCOBJ (hb_max);
+}
+HB_FUNCOBJ (hb_max);
/*
operator () (Type (&array)[length]) const
{ return hb_array_t<Type> (array, length); }
-} HB_FUNCOBJ (hb_iter);
+}
+HB_FUNCOBJ (hb_iter);
/* Mixin to fill in what the subclass doesn't provide. */
template <typename iter_t, typename item_t = typename iter_t::__item_t__>
hb_map_iter_factory_t<Proj>
operator () (Proj&& f) const
{ return hb_map_iter_factory_t<Proj> (f); }
-} HB_FUNCOBJ (hb_map);
+}
+HB_FUNCOBJ (hb_map);
template <typename Iter, typename Pred, typename Proj,
hb_enable_if (hb_is_iterator (Iter))>
hb_filter_iter_factory_t<Pred, Proj>
operator () (Pred&& p = hb_bool, Proj&& f = hb_identity) const
{ return hb_filter_iter_factory_t<Pred, Proj> (p, f); }
-} HB_FUNCOBJ (hb_filter);
+}
+HB_FUNCOBJ (hb_filter);
template <typename Redu, typename InitT>
struct hb_reduce_t
hb_reduce_t<Redu, InitT>
operator () (Redu&& r, InitT init_value) const
{ return hb_reduce_t<Redu, InitT> (r, init_value); }
-} HB_FUNCOBJ (hb_reduce);
+}
+HB_FUNCOBJ (hb_reduce);
/* hb_zip() */
hb_zip_iter_t<hb_iter_t (A), hb_iter_t (B)>
operator () (A& a, B &b) const
{ return hb_zip_iter_t<hb_iter_t (A), hb_iter_t (B)> (hb_iter (a), hb_iter (b)); }
-} HB_FUNCOBJ (hb_zip);
+}
+HB_FUNCOBJ (hb_zip);
/* hb_enumerate */
hb_enumerate_iter_t<hb_iter_t (Iterable)>
operator () (Iterable& it) const
{ return hb_enumerate_iter_t<hb_iter_t (Iterable)> (hb_iter (it)); }
-} HB_FUNCOBJ (hb_enumerate);
+}
+HB_FUNCOBJ (hb_enumerate);
/* hb_apply() */
template <typename Appl> hb_apply_t<Appl&>
operator () (Appl *a) const
{ return hb_apply_t<Appl&> (*a); }
-} HB_FUNCOBJ (hb_apply);
+}
+HB_FUNCOBJ (hb_apply);
/* hb_sink() */
template <typename Sink> hb_sink_t<Sink&>
operator () (Sink *s) const
{ return hb_sink_t<Sink&> (*s); }
-} HB_FUNCOBJ (hb_sink);
+}
+HB_FUNCOBJ (hb_sink);
/* hb-drain: hb_sink to void / blackhole / /dev/null. */
for (; it; ++it)
(void) *it;
}
-} HB_FUNCOBJ (hb_drain);
+}
+HB_FUNCOBJ (hb_drain);
/* hb_unzip(): unzip and sink to two sinks. */
template <typename Sink1, typename Sink2> hb_unzip_t<Sink1&, Sink2&>
operator () (Sink1 *s1, Sink2 *s2) const
{ return hb_unzip_t<Sink1&, Sink2&> (*s1, *s2); }
-} HB_FUNCOBJ (hb_unzip);
+}
+HB_FUNCOBJ (hb_unzip);
/* hb-all, hb-any, hb-none. */
return false;
return true;
}
-} HB_FUNCOBJ (hb_all);
+}
+HB_FUNCOBJ (hb_all);
struct
{
template <typename Iterable,
return true;
return false;
}
-} HB_FUNCOBJ (hb_any);
+}
+HB_FUNCOBJ (hb_any);
struct
{
template <typename Iterable,
return false;
return true;
}
-} HB_FUNCOBJ (hb_none);
+}
+HB_FUNCOBJ (hb_none);
/*
* Algorithms operating on iterators.
reinterpret_cast<const volatile char&> (arg)));
#pragma GCC diagnostic pop
}
-} HB_FUNCOBJ (hb_addressof);
+}
+HB_FUNCOBJ (hb_addressof);
template <typename T> static inline T hb_declval ();
#define hb_declval(T) (hb_declval<T> ())
template <typename T> auto
operator () (T *v) const HB_AUTO_RETURN (*v)
-
-} HB_FUNCOBJ (hb_deref);
+}
+HB_FUNCOBJ (hb_deref);
struct
{
template <typename T> auto
operator () (T& v) const HB_AUTO_RETURN (hb_addressof (v))
-
-} HB_FUNCOBJ (hb_ref);
+}
+HB_FUNCOBJ (hb_ref);
template <typename T>
struct hb_reference_wrapper