From 998b0b68ac2eafd1d5bca51b3723fa753e4db7c4 Mon Sep 17 00:00:00 2001
From: Behdad Esfahbod <behdad@behdad.org>
Date: Thu, 2 May 2019 14:39:52 -0700
Subject: [PATCH] [serializer] Add copy() to (Unsized)ArrayOf

---
 src/hb-open-type.hh | 41 +++++++++++++++++++++++++++++++++++++++++
 src/hb-serialize.hh |  4 ++--
 2 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/src/hb-open-type.hh b/src/hb-open-type.hh
index 808e1829b..6fd6fa652 100644
--- a/src/hb-open-type.hh
+++ b/src/hb-open-type.hh
@@ -409,6 +409,36 @@ struct UnsizedArrayOf
   void qsort (unsigned int len, unsigned int start = 0, unsigned int end = (unsigned int) -1)
   { as_array (len).qsort (start, end); }
 
+  bool serialize (hb_serialize_context_t *c, unsigned int items_len)
+  {
+    TRACE_SERIALIZE (this);
+    if (unlikely (!c->extend (*this, items_len))) return_trace (false);
+    return_trace (true);
+  }
+  template <typename Iterator,
+	    hb_enable_if (hb_is_iterator_of (Iterator, const Type))>
+  bool serialize (hb_serialize_context_t *c, Iterator items)
+  {
+    TRACE_SERIALIZE (this);
+    unsigned count = items.len ();
+    if (unlikely (!serialize (c, count))) return_trace (false);
+    /* TODO Umm. Just exhaust the iterator instead?  Being extra
+     * cautious right now.. */
+    for (unsigned i = 0; i < count; i++, items++)
+      arrayZ[i] = *items;
+    return_trace (true);
+  }
+
+  UnsizedArrayOf* copy (hb_serialize_context_t *c, unsigned count)
+  {
+    TRACE_SERIALIZE (this);
+    auto *out = c->start_embed (*this);
+    if (unlikely (!out->serialize (c, count))) return_trace (nullptr);
+    for (unsigned i = 0; i < count; i++)
+      out->arrayZ[i] = arrayZ[i]; /* TODO: add version that calls c->copy() */
+    return_trace (out);
+  }
+
   bool sanitize (hb_sanitize_context_t *c, unsigned int count) const
   {
     TRACE_SANITIZE (this);
@@ -580,6 +610,17 @@ struct ArrayOf
     return_trace (true);
   }
 
+  ArrayOf* copy (hb_serialize_context_t *c)
+  {
+    TRACE_SERIALIZE (this);
+    auto *out = c->start_embed (*this);
+    unsigned count = len;
+    if (unlikely (!out->serialize (c, count))) return_trace (nullptr);
+    for (unsigned i = 0; i < count; i++)
+      out->arrayZ[i] = arrayZ[i]; /* TODO: add version that calls c->copy() */
+    return_trace (out);
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
diff --git a/src/hb-serialize.hh b/src/hb-serialize.hh
index 61195a4d7..9fa0658b9 100644
--- a/src/hb-serialize.hh
+++ b/src/hb-serialize.hh
@@ -401,8 +401,8 @@ struct hb_serialize_context_t
   template <typename Type>
   Type *extend_min (Type &obj) { return extend_size (obj, obj.min_size); }
 
-  template <typename Type>
-  Type *extend (Type &obj) { return extend_size (obj, obj.get_size ()); }
+  template <typename Type, typename ...Ts>
+  Type *extend (Type &obj, Ts &&...ds) { return extend_size (obj, obj.get_size (hb_forward<Ts> (ds)...)); }
 
   /* Output routines. */
   hb_bytes_t copy_bytes () const