Make VectorFormatter support stateful formatters

ryanofsky · furszy · commit fd29a508c60a · 2021-07-03T09:02:52.000-03:00
diff --git a/src/prevector.h b/src/prevector.h
@@ -422,15 +422,20 @@ class prevector {
         return first;
     }
 
-    void push_back(const T& value) {
+    template<typename... Args>
+    void emplace_back(Args&&... args) {
         size_type new_size = size() + 1;
         if (capacity() < new_size) {
             change_capacity(new_size + (new_size >> 1));
         }
-        new(item_ptr(size())) T(value);
+        new(item_ptr(size())) T(std::forward<Args>(args)...);
         _size++;
     }
 
+    void push_back(const T& value) {
+        emplace_back(value);
+    }
+
     void pop_back() {
         erase(end() - 1, end());
     }
diff --git a/src/serialize.h b/src/serialize.h
@@ -643,23 +643,25 @@ BigEndian<I> WrapBigEndian(I& n) { return BigEndian<I>(n); }
  * as a vector of VarInt-encoded integers.
  *
  * V is not required to be an std::vector type. It works for any class that
- * exposes a value_type, size, reserve, push_back, and const iterators.
+ * exposes a value_type, size, reserve, emplace_back, back, and const iterators.
  */
 template<class Formatter>
 struct VectorFormatter
 {
     template<typename Stream, typename V>
     void Ser(Stream& s, const V& v)
     {
+        Formatter formatter;
         WriteCompactSize(s, v.size());
         for (const typename V::value_type& elem : v) {
-            s << Using<Formatter>(elem);
+            formatter.Ser(s, elem);
         }
     }
 
     template<typename Stream, typename V>
     void Unser(Stream& s, V& v)
     {
+        Formatter formatter;
         v.clear();
         size_t size = ReadCompactSize(s);
         size_t allocated = 0;
@@ -671,9 +673,8 @@ struct VectorFormatter
             allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
             v.reserve(allocated);
             while (v.size() < allocated) {
-                typename V::value_type val;
-                s >> Using<Formatter>(val);
-                v.push_back(std::move(val));
+                v.emplace_back();
+                formatter.Unser(s, v.back());
             }
         }
     };

Original file line number	Diff line number	Diff line change
`@@ -422,15 +422,20 @@ class prevector {`
`422`	`422`	`return first;`
`423`	`423`	`}`
`424`	`424`
`425`		`- void push_back(const T& value) {`
	`425`	`+ template<typename... Args>`
	`426`	`+ void emplace_back(Args&&... args) {`
`426`	`427`	`size_type new_size = size() + 1;`
`427`	`428`	`if (capacity() < new_size) {`
`428`	`429`	`change_capacity(new_size + (new_size >> 1));`
`429`	`430`	`}`
`430`		`- new(item_ptr(size())) T(value);`
	`431`	`+ new(item_ptr(size())) T(std::forward<Args>(args)...);`
`431`	`432`	`_size++;`
`432`	`433`	`}`
`433`	`434`
	`435`	`+ void push_back(const T& value) {`
	`436`	`+ emplace_back(value);`
	`437`	`+ }`
	`438`	`+`
`434`	`439`	`void pop_back() {`
`435`	`440`	`erase(end() - 1, end());`
`436`	`441`	`}`
Original file line number	Diff line number	Diff line change
`@@ -643,23 +643,25 @@ BigEndian<I> WrapBigEndian(I& n) { return BigEndian<I>(n); }`
`643`	`643`	`* as a vector of VarInt-encoded integers.`
`644`	`644`	`*`
`645`	`645`	`* V is not required to be an std::vector type. It works for any class that`
`646`		`- * exposes a value_type, size, reserve, push_back, and const iterators.`
	`646`	`+ * exposes a value_type, size, reserve, emplace_back, back, and const iterators.`
`647`	`647`	`*/`
`648`	`648`	`template<class Formatter>`
`649`	`649`	`struct VectorFormatter`
`650`	`650`	`{`
`651`	`651`	`template<typename Stream, typename V>`
`652`	`652`	`void Ser(Stream& s, const V& v)`
`653`	`653`	`{`
	`654`	`+ Formatter formatter;`
`654`	`655`	`WriteCompactSize(s, v.size());`
`655`	`656`	`for (const typename V::value_type& elem : v) {`
`656`		`- s << Using<Formatter>(elem);`
	`657`	`+ formatter.Ser(s, elem);`
`657`	`658`	`}`
`658`	`659`	`}`
`659`	`660`
`660`	`661`	`template<typename Stream, typename V>`
`661`	`662`	`void Unser(Stream& s, V& v)`
`662`	`663`	`{`
	`664`	`+ Formatter formatter;`
`663`	`665`	`v.clear();`
`664`	`666`	`size_t size = ReadCompactSize(s);`
`665`	`667`	`size_t allocated = 0;`
`@@ -671,9 +673,8 @@ struct VectorFormatter`
`671`	`673`	`allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));`
`672`	`674`	`v.reserve(allocated);`
`673`	`675`	`while (v.size() < allocated) {`
`674`		`- typename V::value_type val;`
`675`		`- s >> Using<Formatter>(val);`
`676`		`- v.push_back(std::move(val));`
	`676`	`+ v.emplace_back();`
	`677`	`+ formatter.Unser(s, v.back());`
`677`	`678`	`}`
`678`	`679`	`}`
`679`	`680`	`};`