1#ifndef OT_LAYOUT_GSUB_MULTIPLESUBSTFORMAT1_HH
2#define OT_LAYOUT_GSUB_MULTIPLESUBSTFORMAT1_HH
3
4#include "Common.hh"
5#include "Sequence.hh"
6
7namespace OT {
8namespace Layout {
9namespace GSUB_impl {
10
11template <typename Types>
12struct MultipleSubstFormat1_2
13{
14 protected:
15 HBUINT16 format; /* Format identifier--format = 1 */
16 typename Types::template OffsetTo<Coverage>
17 coverage; /* Offset to Coverage table--from
18 * beginning of Substitution table */
19 Array16Of<typename Types::template OffsetTo<Sequence<Types>>>
20 sequence; /* Array of Sequence tables
21 * ordered by Coverage Index */
22 public:
23 DEFINE_SIZE_ARRAY (4 + Types::size, sequence);
24
25 bool sanitize (hb_sanitize_context_t *c) const
26 {
27 TRACE_SANITIZE (this);
28 return_trace (coverage.sanitize (c, this) && sequence.sanitize (c, this));
29 }
30
31 bool intersects (const hb_set_t *glyphs) const
32 { return (this+coverage).intersects (glyphs); }
33
34 bool may_have_non_1to1 () const
35 { return true; }
36
37 void closure (hb_closure_context_t *c) const
38 {
39 + hb_zip (this+coverage, sequence)
40 | hb_filter (c->parent_active_glyphs (), hb_first)
41 | hb_map (hb_second)
42 | hb_map (hb_add (this))
43 | hb_apply ([c] (const Sequence<Types> &_) { _.closure (c); })
44 ;
45 }
46
47 void closure_lookups (hb_closure_lookups_context_t *c) const {}
48
49 void collect_glyphs (hb_collect_glyphs_context_t *c) const
50 {
51 if (unlikely (!(this+coverage).collect_coverage (c->input))) return;
52 + hb_zip (this+coverage, sequence)
53 | hb_map (hb_second)
54 | hb_map (hb_add (this))
55 | hb_apply ([c] (const Sequence<Types> &_) { _.collect_glyphs (c); })
56 ;
57 }
58
59 const Coverage &get_coverage () const { return this+coverage; }
60
61 bool would_apply (hb_would_apply_context_t *c) const
62 { return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; }
63
64 bool apply (hb_ot_apply_context_t *c) const
65 {
66 TRACE_APPLY (this);
67
68 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
69 if (likely (index == NOT_COVERED)) return_trace (false);
70
71 return_trace ((this+sequence[index]).apply (c));
72 }
73
74 template<typename Iterator,
75 hb_requires (hb_is_sorted_iterator (Iterator))>
76 bool serialize (hb_serialize_context_t *c,
77 Iterator it)
78 {
79 TRACE_SERIALIZE (this);
80 auto sequences =
81 + it
82 | hb_map (hb_second)
83 ;
84 auto glyphs =
85 + it
86 | hb_map_retains_sorting (hb_first)
87 ;
88 if (unlikely (!c->extend_min (this))) return_trace (false);
89
90 if (unlikely (!sequence.serialize (c, sequences.length))) return_trace (false);
91
92 for (auto& pair : hb_zip (sequences, sequence))
93 {
94 if (unlikely (!pair.second
95 .serialize_serialize (c, pair.first)))
96 return_trace (false);
97 }
98
99 return_trace (coverage.serialize_serialize (c, glyphs));
100 }
101
102 bool subset (hb_subset_context_t *c) const
103 {
104 TRACE_SUBSET (this);
105 const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
106 const hb_map_t &glyph_map = *c->plan->glyph_map;
107
108 auto *out = c->serializer->start_embed (*this);
109 if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
110 out->format = format;
111
112 hb_sorted_vector_t<hb_codepoint_t> new_coverage;
113 + hb_zip (this+coverage, sequence)
114 | hb_filter (glyphset, hb_first)
115 | hb_filter (subset_offset_array (c, out->sequence, this), hb_second)
116 | hb_map (hb_first)
117 | hb_map (glyph_map)
118 | hb_sink (new_coverage)
119 ;
120 out->coverage.serialize_serialize (c->serializer, new_coverage.iter ());
121 return_trace (bool (new_coverage));
122 }
123};
124
125}
126}
127}
128
129
130#endif /* OT_LAYOUT_GSUB_MULTIPLESUBSTFORMAT1_HH */
131