typedef Return return_t;
template <typename T, typename F>
bool may_dispatch (const T *obj HB_UNUSED, const F *format HB_UNUSED) { return true; }
- template <typename T>
- return_t dispatch (const T &obj) { return _dispatch_impl (obj, hb_prioritize); }
+ template <typename T, typename ...Ts>
+ return_t dispatch (const T &obj, Ts &&...ds)
+ { return _dispatch_impl (obj, hb_prioritize, hb_forward<Ts> (ds)...); }
static return_t no_dispatch_return_value () { return Context::default_return_value (); }
static bool stop_sublookup_iteration (const return_t r HB_UNUSED) { return false; }
private:
- template <typename T>
- auto _dispatch_impl (const T &obj, hb_priority<1>) HB_AUTO_RETURN (obj.dispatch (thiz ()))
- template <typename T>
- Return _dispatch_impl (const T &obj, hb_priority<0>) { return thiz()->_dispatch (obj); }
+ template <typename T, typename ...Ts>
+ auto _dispatch_impl (const T &obj, hb_priority<1>, Ts &&...ds) HB_AUTO_RETURN
+ (obj.dispatch (thiz (), hb_forward<Ts> (ds)...))
+ template <typename T, typename ...Ts>
+ Return _dispatch_impl (const T &obj, hb_priority<0>, Ts &&...ds)
+ { return thiz()->_dispatch (obj, hb_forward<Ts> (ds)...); }
};
s->push ();
- bool ret = src.subset (c, hb_forward<Ts> (ds)...);
+ bool ret = c->dispatch (src, hb_forward<Ts> (ds)...);
if (ret || !has_null)
s->add_link (*this, s->pop_pack (), base);
TRACE_SANITIZE (this);
return_trace (sanitize_shallow (c, base) &&
(this->is_null () ||
- StructAtOffset<Type> (base, *this).sanitize (c, hb_forward<Ts> (ds)...) ||
+ c->dispatch (StructAtOffset<Type> (base, *this), hb_forward<Ts> (ds)...) ||
neuter (c)));
}
TRACE_SANITIZE (this);
if (unlikely (!sanitize_shallow (c, count))) return_trace (false);
for (unsigned int i = 0; i < count; i++)
- if (unlikely (!arrayZ[i].sanitize (c, hb_forward<Ts> (ds)...)))
+ if (unlikely (!c->dispatch (arrayZ[i], hb_forward<Ts> (ds)...)))
return_trace (false);
return_trace (true);
}
if (unlikely (!sanitize_shallow (c))) return_trace (false);
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
- if (unlikely (!arrayZ[i].sanitize (c, hb_forward<Ts> (ds)...)))
+ if (unlikely (!c->dispatch (arrayZ[i], hb_forward<Ts> (ds)...)))
return_trace (false);
return_trace (true);
}
if (unlikely (!sanitize_shallow (c))) return_trace (false);
unsigned int count = lenM1 + 1;
for (unsigned int i = 0; i < count; i++)
- if (unlikely (!arrayZ[i].sanitize (c, hb_forward<Ts> (ds)...)))
+ if (unlikely (!c->dispatch (arrayZ[i], hb_forward<Ts> (ds)...)))
return_trace (false);
return_trace (true);
}
}
}
- /* XXX Remove? */
- bool subset (hb_subset_context_t *c, unsigned lookup_type) const
- { return dispatch (c, lookup_type); }
- bool sanitize (hb_sanitize_context_t *c, unsigned lookup_type) const
- { return dispatch (c, lookup_type); }
-
protected:
union {
SinglePos single;
}
}
- /* XXX Remove? */
- bool subset (hb_subset_context_t *c, unsigned lookup_type) const
- { return dispatch (c, lookup_type); }
- bool sanitize (hb_sanitize_context_t *c, unsigned lookup_type) const
- { return dispatch (c, lookup_type); }
-
protected:
union {
SingleSubst single;
template <typename T, typename F>
bool may_dispatch (const T *obj HB_UNUSED, const F *format)
{ return format->sanitize (this); }
- template <typename T>
- return_t _dispatch (const T &obj) { return obj.sanitize (this); }
+ template <typename T, typename ...Ts>
+ return_t _dispatch (const T &obj, Ts &&...ds)
+ { return obj.sanitize (this, hb_forward<Ts> (ds)...); }
static return_t default_return_value () { return true; }
static return_t no_dispatch_return_value () { return false; }
bool stop_sublookup_iteration (const return_t r) const { return !r; }
hb_dispatch_context_t<hb_subset_context_t, bool, HB_DEBUG_SUBSET>
{
const char *get_name () { return "SUBSET"; }
- template <typename T>
- return_t _dispatch (const T &obj) { return obj.subset (this); }
+ template <typename T, typename ...Ts>
+ return_t _dispatch (const T &obj, Ts &&...ds)
+ { return obj.subset (this, hb_forward<Ts> (ds)...); }
static return_t default_return_value () { return true; }
hb_subset_plan_t *plan;