Upgrade protozero to version 1.5.2

protozero/pbf_writer.hpp

@@ -22,6 +22,7 @@ documentation.
 #include <iterator>
 #include <limits>
 #include <string>
+#include <utility>
 
 #include <protozero/config.hpp>
 #include <protozero/types.hpp>
@@ -68,38 +69,35 @@ class pbf_writer {
     // parent to the position where the data of the submessage is written to.
     std::size_t m_pos = 0;
 
-    inline void add_varint(uint64_t value) {
+    void add_varint(uint64_t value) {
         protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
         protozero_assert(m_data);
         write_varint(std::back_inserter(*m_data), value);
     }
 
-    inline void add_field(pbf_tag_type tag, pbf_wire_type type) {
+    void add_field(pbf_tag_type tag, pbf_wire_type type) {
         protozero_assert(((tag > 0 && tag < 19000) || (tag > 19999 && tag <= ((1 << 29) - 1))) && "tag out of range");
-        uint32_t b = (tag << 3) | uint32_t(type);
+        const uint32_t b = (tag << 3) | uint32_t(type);
         add_varint(b);
     }
 
-    inline void add_tagged_varint(pbf_tag_type tag, uint64_t value) {
+    void add_tagged_varint(pbf_tag_type tag, uint64_t value) {
         add_field(tag, pbf_wire_type::varint);
         add_varint(value);
     }
 
     template <typename T>
-    inline void add_fixed(T value) {
+    void add_fixed(T value) {
         protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
         protozero_assert(m_data);
-#if PROTOZERO_BYTE_ORDER == PROTOZERO_LITTLE_ENDIAN
-        m_data->append(reinterpret_cast<const char*>(&value), sizeof(T));
-#else
-        auto size = m_data->size();
-        m_data->resize(size + sizeof(T));
-        byteswap<sizeof(T)>(reinterpret_cast<const char*>(&value), const_cast<char*>(m_data->data() + size));
+#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
+        detail::byteswap_inplace(&value);
 #endif
+        m_data->append(reinterpret_cast<const char*>(&value), sizeof(T));
     }
 
     template <typename T, typename It>
-    inline void add_packed_fixed(pbf_tag_type tag, It first, It last, std::input_iterator_tag) {
+    void add_packed_fixed(pbf_tag_type tag, It first, It last, std::input_iterator_tag) {
         if (first == last) {
             return;
         }
@@ -112,12 +110,12 @@ class pbf_writer {
     }
 
     template <typename T, typename It>
-    inline void add_packed_fixed(pbf_tag_type tag, It first, It last, std::forward_iterator_tag) {
+    void add_packed_fixed(pbf_tag_type tag, It first, It last, std::forward_iterator_tag) {
         if (first == last) {
             return;
         }
 
-        auto length = std::distance(first, last);
+        const auto length = std::distance(first, last);
         add_length_varint(tag, sizeof(T) * pbf_length_type(length));
         reserve(sizeof(T) * std::size_t(length));
 
@@ -127,7 +125,7 @@ class pbf_writer {
     }
 
     template <typename It>
-    inline void add_packed_varint(pbf_tag_type tag, It first, It last) {
+    void add_packed_varint(pbf_tag_type tag, It first, It last) {
         if (first == last) {
             return;
         }
@@ -140,7 +138,7 @@ class pbf_writer {
     }
 
     template <typename It>
-    inline void add_packed_svarint(pbf_tag_type tag, It first, It last) {
+    void add_packed_svarint(pbf_tag_type tag, It first, It last) {
         if (first == last) {
             return;
         }
@@ -155,14 +153,18 @@ class pbf_writer {
     // The number of bytes to reserve for the varint holding the length of
     // a length-delimited field. The length has to fit into pbf_length_type,
     // and a varint needs 8 bit for every 7 bit.
-    static const int reserve_bytes = sizeof(pbf_length_type) * 8 / 7 + 1;
+    enum constant_reserve_bytes : int {
+        reserve_bytes = sizeof(pbf_length_type) * 8 / 7 + 1
+    };
 
     // If m_rollpack_pos is set to this special value, it means that when
     // the submessage is closed, nothing needs to be done, because the length
     // of the submessage has already been written correctly.
-    static const std::size_t size_is_known = std::numeric_limits<std::size_t>::max();
+    enum constant_size_is_known : std::size_t {
+        size_is_known = std::numeric_limits<std::size_t>::max()
+    };
 
-    inline void open_submessage(pbf_tag_type tag, std::size_t size) {
+    void open_submessage(pbf_tag_type tag, std::size_t size) {
         protozero_assert(m_pos == 0);
         protozero_assert(m_data);
         if (size == 0) {
@@ -177,7 +179,7 @@ class pbf_writer {
         m_pos = m_data->size();
     }
 
-    inline void rollback_submessage() {
+    void rollback_submessage() {
         protozero_assert(m_pos != 0);
         protozero_assert(m_rollback_pos != size_is_known);
         protozero_assert(m_data);
@@ -185,20 +187,20 @@ class pbf_writer {
         m_pos = 0;
     }
 
-    inline void commit_submessage() {
+    void commit_submessage() {
         protozero_assert(m_pos != 0);
         protozero_assert(m_rollback_pos != size_is_known);
         protozero_assert(m_data);
-        auto length = pbf_length_type(m_data->size() - m_pos);
+        const auto length = pbf_length_type(m_data->size() - m_pos);
 
         protozero_assert(m_data->size() >= m_pos - reserve_bytes);
-        auto n = write_varint(m_data->begin() + long(m_pos) - reserve_bytes, length);
+        const auto n = write_varint(m_data->begin() + long(m_pos) - reserve_bytes, length);
 
         m_data->erase(m_data->begin() + long(m_pos) - reserve_bytes + n, m_data->begin() + long(m_pos));
         m_pos = 0;
     }
 
-    inline void close_submessage() {
+    void close_submessage() {
         protozero_assert(m_data);
         if (m_pos == 0 || m_rollback_pos == size_is_known) {
             return;
@@ -210,7 +212,7 @@ class pbf_writer {
         }
     }
 
-    inline void add_length_varint(pbf_tag_type tag, pbf_length_type length) {
+    void add_length_varint(pbf_tag_type tag, pbf_length_type length) {
         add_field(tag, pbf_wire_type::length_delimited);
         add_varint(length);
     }
@@ -222,20 +224,18 @@ public:
      * stores a reference to that string and adds all data to it. The string
      * doesn't have to be empty. The pbf_writer will just append data.
      */
-    inline explicit pbf_writer(std::string& data) noexcept :
+    explicit pbf_writer(std::string& data) noexcept :
         m_data(&data),
-        m_parent_writer(nullptr),
-        m_pos(0) {
+        m_parent_writer(nullptr) {
     }
 
     /**
      * Create a writer without a data store. In this form the writer can not
      * be used!
      */
-    inline pbf_writer() noexcept :
+    pbf_writer() noexcept :
         m_data(nullptr),
-        m_parent_writer(nullptr),
-        m_pos(0) {
+        m_parent_writer(nullptr) {
     }
 
     /**
@@ -248,10 +248,9 @@ public:
      *        Setting this allows some optimizations but is only possible in
      *        a few very specific cases.
      */
-    inline pbf_writer(pbf_writer& parent_writer, pbf_tag_type tag, std::size_t size=0) :
+    pbf_writer(pbf_writer& parent_writer, pbf_tag_type tag, std::size_t size=0) :
         m_data(parent_writer.m_data),
-        m_parent_writer(&parent_writer),
-        m_pos(0) {
+        m_parent_writer(&parent_writer) {
         m_parent_writer->open_submessage(tag, size);
     }
 
@@ -262,17 +261,30 @@ public:
     pbf_writer& operator=(const pbf_writer&) noexcept = default;
 
     /// A pbf_writer object can be moved
-    inline pbf_writer(pbf_writer&&) noexcept = default;
+    pbf_writer(pbf_writer&&) noexcept = default;
 
     /// A pbf_writer object can be moved
-    inline pbf_writer& operator=(pbf_writer&&) noexcept = default;
+    pbf_writer& operator=(pbf_writer&&) noexcept = default;
 
-    inline ~pbf_writer() {
+    ~pbf_writer() {
         if (m_parent_writer) {
             m_parent_writer->close_submessage();
         }
     }
 
+    /**
+     * Swap the contents of this object with the other.
+     *
+     * @param other Other object to swap data with.
+     */
+    void swap(pbf_writer& other) noexcept {
+        using std::swap;
+        swap(m_data, other.m_data);
+        swap(m_parent_writer, other.m_parent_writer);
+        swap(m_rollback_pos, other.m_rollback_pos);
+        swap(m_pos, other.m_pos);
+    }
+
     /**
      * Reserve size bytes in the underlying message store in addition to
      * whatever the message store already holds. So unlike
@@ -286,7 +298,14 @@ public:
         m_data->reserve(m_data->size() + size);
     }
 
-    inline void rollback() {
+    /**
+     * Cancel writing of this submessage. The complete submessage will be
+     * removed as if it was never created and no fields were added.
+     *
+     * @pre Must be a pbf_writer of a submessage, ie one opened with the
+     *      pbf_writer constructor taking a parent message.
+     */
+    void rollback() {
         protozero_assert(m_parent_writer && "you can't call rollback() on a pbf_writer without a parent");
         protozero_assert(m_pos == 0 && "you can't call rollback() on a pbf_writer that has an open nested submessage");
         m_parent_writer->rollback_submessage();
@@ -304,7 +323,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_bool(pbf_tag_type tag, bool value) {
+    void add_bool(pbf_tag_type tag, bool value) {
         add_field(tag, pbf_wire_type::varint);
         protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
         protozero_assert(m_data);
@@ -317,7 +336,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_enum(pbf_tag_type tag, int32_t value) {
+    void add_enum(pbf_tag_type tag, int32_t value) {
         add_tagged_varint(tag, uint64_t(value));
     }
 
@@ -327,7 +346,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_int32(pbf_tag_type tag, int32_t value) {
+    void add_int32(pbf_tag_type tag, int32_t value) {
         add_tagged_varint(tag, uint64_t(value));
     }
 
@@ -337,7 +356,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_sint32(pbf_tag_type tag, int32_t value) {
+    void add_sint32(pbf_tag_type tag, int32_t value) {
         add_tagged_varint(tag, encode_zigzag32(value));
     }
 
@@ -347,7 +366,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_uint32(pbf_tag_type tag, uint32_t value) {
+    void add_uint32(pbf_tag_type tag, uint32_t value) {
         add_tagged_varint(tag, value);
     }
 
@@ -357,7 +376,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_int64(pbf_tag_type tag, int64_t value) {
+    void add_int64(pbf_tag_type tag, int64_t value) {
         add_tagged_varint(tag, uint64_t(value));
     }
 
@@ -367,7 +386,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_sint64(pbf_tag_type tag, int64_t value) {
+    void add_sint64(pbf_tag_type tag, int64_t value) {
         add_tagged_varint(tag, encode_zigzag64(value));
     }
 
@@ -377,7 +396,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_uint64(pbf_tag_type tag, uint64_t value) {
+    void add_uint64(pbf_tag_type tag, uint64_t value) {
         add_tagged_varint(tag, value);
     }
 
@@ -387,7 +406,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_fixed32(pbf_tag_type tag, uint32_t value) {
+    void add_fixed32(pbf_tag_type tag, uint32_t value) {
         add_field(tag, pbf_wire_type::fixed32);
         add_fixed<uint32_t>(value);
     }
@@ -398,7 +417,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_sfixed32(pbf_tag_type tag, int32_t value) {
+    void add_sfixed32(pbf_tag_type tag, int32_t value) {
         add_field(tag, pbf_wire_type::fixed32);
         add_fixed<int32_t>(value);
     }
@@ -409,7 +428,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_fixed64(pbf_tag_type tag, uint64_t value) {
+    void add_fixed64(pbf_tag_type tag, uint64_t value) {
         add_field(tag, pbf_wire_type::fixed64);
         add_fixed<uint64_t>(value);
     }
@@ -420,7 +439,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_sfixed64(pbf_tag_type tag, int64_t value) {
+    void add_sfixed64(pbf_tag_type tag, int64_t value) {
         add_field(tag, pbf_wire_type::fixed64);
         add_fixed<int64_t>(value);
     }
@@ -431,7 +450,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_float(pbf_tag_type tag, float value) {
+    void add_float(pbf_tag_type tag, float value) {
         add_field(tag, pbf_wire_type::fixed32);
         add_fixed<float>(value);
     }
@@ -442,7 +461,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_double(pbf_tag_type tag, double value) {
+    void add_double(pbf_tag_type tag, double value) {
         add_field(tag, pbf_wire_type::fixed64);
         add_fixed<double>(value);
     }
@@ -454,7 +473,7 @@ public:
      * @param value Pointer to value to be written
      * @param size Number of bytes to be written
      */
-    inline void add_bytes(pbf_tag_type tag, const char* value, std::size_t size) {
+    void add_bytes(pbf_tag_type tag, const char* value, std::size_t size) {
         protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
         protozero_assert(m_data);
         protozero_assert(size <= std::numeric_limits<pbf_length_type>::max());
@@ -468,10 +487,62 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_bytes(pbf_tag_type tag, const std::string& value) {
+    void add_bytes(pbf_tag_type tag, const data_view& value) {
         add_bytes(tag, value.data(), value.size());
     }
 
+    /**
+     * Add "bytes" field to data.
+     *
+     * @param tag Tag (field number) of the field
+     * @param value Value to be written
+     */
+    void add_bytes(pbf_tag_type tag, const std::string& value) {
+        add_bytes(tag, value.data(), value.size());
+    }
+
+    /**
+     * Add "bytes" field to data. Bytes from the value are written until
+     * a null byte is encountered. The null byte is not added.
+     *
+     * @param tag Tag (field number) of the field
+     * @param value Pointer to zero-delimited value to be written
+     */
+    void add_bytes(pbf_tag_type tag, const char* value) {
+        add_bytes(tag, value, std::strlen(value));
+    }
+
+    /**
+     * Add "bytes" field to data using vectored input. All the data in the
+     * 2nd and further arguments is "concatenated" with only a single copy
+     * into the final buffer.
+     *
+     * This will work with objects of any type supporting the data() and
+     * size() methods like std::string or protozero::data_view.
+     *
+     * Example:
+     * @code
+     * std::string data1 = "abc";
+     * std::string data2 = "xyz";
+     * writer.add_bytes_vectored(1, data1, data2);
+     * @endcode
+     *
+     * @tparam Ts List of types supporting data() and size() methods.
+     * @param tag Tag (field number) of the field
+     * @param values List of objects of types Ts with data to be appended.
+     */
+    template <typename... Ts>
+    void add_bytes_vectored(pbf_tag_type tag, Ts&&... values) {
+        protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
+        protozero_assert(m_data);
+        size_t sum_size = 0;
+        (void)std::initializer_list<size_t>{sum_size += values.size()...};
+        protozero_assert(sum_size <= std::numeric_limits<pbf_length_type>::max());
+        add_length_varint(tag, pbf_length_type(sum_size));
+        m_data->reserve(m_data->size() + sum_size);
+        (void)std::initializer_list<int>{(m_data->append(values.data(), values.size()), 0)...};
+    }
+
     /**
      * Add "string" field to data.
      *
@@ -479,7 +550,7 @@ public:
      * @param value Pointer to value to be written
      * @param size Number of bytes to be written
      */
-    inline void add_string(pbf_tag_type tag, const char* value, std::size_t size) {
+    void add_string(pbf_tag_type tag, const char* value, std::size_t size) {
         add_bytes(tag, value, size);
     }
 
@@ -489,7 +560,17 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written
      */
-    inline void add_string(pbf_tag_type tag, const std::string& value) {
+    void add_string(pbf_tag_type tag, const data_view& value) {
+        add_bytes(tag, value.data(), value.size());
+    }
+
+    /**
+     * Add "string" field to data.
+     *
+     * @param tag Tag (field number) of the field
+     * @param value Value to be written
+     */
+    void add_string(pbf_tag_type tag, const std::string& value) {
         add_bytes(tag, value.data(), value.size());
     }
 
@@ -500,7 +581,7 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Pointer to value to be written
      */
-    inline void add_string(pbf_tag_type tag, const char* value) {
+    void add_string(pbf_tag_type tag, const char* value) {
         add_bytes(tag, value, std::strlen(value));
     }
 
@@ -511,7 +592,7 @@ public:
      * @param value Pointer to message to be written
      * @param size Length of the message
      */
-    inline void add_message(pbf_tag_type tag, const char* value, std::size_t size) {
+    void add_message(pbf_tag_type tag, const char* value, std::size_t size) {
         add_bytes(tag, value, size);
     }
 
@@ -521,7 +602,17 @@ public:
      * @param tag Tag (field number) of the field
      * @param value Value to be written. The value must be a complete message.
      */
-    inline void add_message(pbf_tag_type tag, const std::string& value) {
+    void add_message(pbf_tag_type tag, const data_view& value) {
+        add_bytes(tag, value.data(), value.size());
+    }
+
+    /**
+     * Add "message" field to data.
+     *
+     * @param tag Tag (field number) of the field
+     * @param value Value to be written. The value must be a complete message.
+     */
+    void add_message(pbf_tag_type tag, const std::string& value) {
         add_bytes(tag, value.data(), value.size());
     }
 
@@ -535,126 +626,126 @@ public:
     /**
      * Add "repeated packed bool" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to bool.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_bool(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_bool(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_varint(tag, first, last);
     }
 
     /**
      * Add "repeated packed enum" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int32_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_enum(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_enum(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_varint(tag, first, last);
     }
 
     /**
      * Add "repeated packed int32" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int32_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_int32(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_int32(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_varint(tag, first, last);
     }
 
     /**
      * Add "repeated packed sint32" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int32_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_sint32(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_sint32(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_svarint(tag, first, last);
     }
 
     /**
      * Add "repeated packed uint32" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to uint32_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_uint32(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_uint32(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_varint(tag, first, last);
     }
 
     /**
      * Add "repeated packed int64" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int64_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_int64(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_int64(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_varint(tag, first, last);
     }
 
     /**
      * Add "repeated packed sint64" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int64_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_sint64(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_sint64(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_svarint(tag, first, last);
     }
 
     /**
      * Add "repeated packed uint64" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to uint64_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_uint64(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_uint64(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_varint(tag, first, last);
     }
 
     /**
      * Add "repeated packed fixed32" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to uint32_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_fixed32(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_fixed32(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_fixed<uint32_t, InputIterator>(tag, first, last,
             typename std::iterator_traits<InputIterator>::iterator_category());
     }
@@ -662,14 +753,14 @@ public:
     /**
      * Add "repeated packed sfixed32" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int32_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_sfixed32(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_sfixed32(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_fixed<int32_t, InputIterator>(tag, first, last,
             typename std::iterator_traits<InputIterator>::iterator_category());
     }
@@ -677,14 +768,14 @@ public:
     /**
      * Add "repeated packed fixed64" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to uint64_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_fixed64(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_fixed64(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_fixed<uint64_t, InputIterator>(tag, first, last,
             typename std::iterator_traits<InputIterator>::iterator_category());
     }
@@ -692,14 +783,14 @@ public:
     /**
      * Add "repeated packed sfixed64" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to int64_t.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_sfixed64(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_sfixed64(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_fixed<int64_t, InputIterator>(tag, first, last,
             typename std::iterator_traits<InputIterator>::iterator_category());
     }
@@ -707,14 +798,14 @@ public:
     /**
      * Add "repeated packed float" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to float.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_float(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_float(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_fixed<float, InputIterator>(tag, first, last,
             typename std::iterator_traits<InputIterator>::iterator_category());
     }
@@ -722,14 +813,14 @@ public:
     /**
      * Add "repeated packed double" field to data.
      *
-     * @tparam InputIterator An type satisfying the InputIterator concept.
+     * @tparam InputIterator A type satisfying the InputIterator concept.
      *         Dereferencing the iterator must yield a type assignable to double.
      * @param tag Tag (field number) of the field
      * @param first Iterator pointing to the beginning of the data
      * @param last Iterator pointing one past the end of data
      */
     template <typename InputIterator>
-    inline void add_packed_double(pbf_tag_type tag, InputIterator first, InputIterator last) {
+    void add_packed_double(pbf_tag_type tag, InputIterator first, InputIterator last) {
         add_packed_fixed<double, InputIterator>(tag, first, last,
             typename std::iterator_traits<InputIterator>::iterator_category());
     }
@@ -742,6 +833,16 @@ public:
 
 }; // class pbf_writer
 
+/**
+ * Swap two pbf_writer objects.
+ *
+ * @param lhs First object.
+ * @param rhs Second object.
+ */
+inline void swap(pbf_writer& lhs, pbf_writer& rhs) noexcept {
+    lhs.swap(rhs);
+}
+
 namespace detail {
 
     class packed_field {
@@ -752,6 +853,12 @@ namespace detail {
 
     public:
 
+        packed_field(const packed_field&) = delete;
+        packed_field& operator=(const packed_field&) = delete;
+
+        packed_field(packed_field&&) = default;
+        packed_field& operator=(packed_field&&) = default;
+
         packed_field(pbf_writer& parent_writer, pbf_tag_type tag) :
             m_writer(parent_writer, tag) {
         }
@@ -771,12 +878,14 @@ namespace detail {
 
     public:
 
-        packed_field_fixed(pbf_writer& parent_writer, pbf_tag_type tag) :
-            packed_field(parent_writer, tag) {
+        template <typename P>
+        packed_field_fixed(pbf_writer& parent_writer, P tag) :
+            packed_field(parent_writer, static_cast<pbf_tag_type>(tag)) {
         }
 
-        packed_field_fixed(pbf_writer& parent_writer, pbf_tag_type tag, std::size_t size) :
-            packed_field(parent_writer, tag, size * sizeof(T)) {
+        template <typename P>
+        packed_field_fixed(pbf_writer& parent_writer, P tag, std::size_t size) :
+            packed_field(parent_writer, static_cast<pbf_tag_type>(tag), size * sizeof(T)) {
         }
 
         void add_element(T value) {
@@ -790,8 +899,9 @@ namespace detail {
 
     public:
 
-        packed_field_varint(pbf_writer& parent_writer, pbf_tag_type tag) :
-            packed_field(parent_writer, tag) {
+        template <typename P>
+        packed_field_varint(pbf_writer& parent_writer, P tag) :
+            packed_field(parent_writer, static_cast<pbf_tag_type>(tag)) {
         }
 
         void add_element(T value) {
@@ -805,8 +915,9 @@ namespace detail {
 
     public:
 
-        packed_field_svarint(pbf_writer& parent_writer, pbf_tag_type tag) :
-            packed_field(parent_writer, tag) {
+        template <typename P>
+        packed_field_svarint(pbf_writer& parent_writer, P tag) :
+            packed_field(parent_writer, static_cast<pbf_tag_type>(tag)) {
         }
 
         void add_element(T value) {
@@ -817,19 +928,46 @@ namespace detail {
 
 } // end namespace detail
 
+/// Class for generating packed repeated bool fields.
 using packed_field_bool     = detail::packed_field_varint<bool>;
+
+/// Class for generating packed repeated enum fields.
 using packed_field_enum     = detail::packed_field_varint<int32_t>;
+
+/// Class for generating packed repeated int32 fields.
 using packed_field_int32    = detail::packed_field_varint<int32_t>;
+
+/// Class for generating packed repeated sint32 fields.
 using packed_field_sint32   = detail::packed_field_svarint<int32_t>;
+
+/// Class for generating packed repeated uint32 fields.
 using packed_field_uint32   = detail::packed_field_varint<uint32_t>;
+
+/// Class for generating packed repeated int64 fields.
 using packed_field_int64    = detail::packed_field_varint<int64_t>;
+
+/// Class for generating packed repeated sint64 fields.
 using packed_field_sint64   = detail::packed_field_svarint<int64_t>;
+
+/// Class for generating packed repeated uint64 fields.
 using packed_field_uint64   = detail::packed_field_varint<uint64_t>;
+
+/// Class for generating packed repeated fixed32 fields.
 using packed_field_fixed32  = detail::packed_field_fixed<uint32_t>;
+
+/// Class for generating packed repeated sfixed32 fields.
 using packed_field_sfixed32 = detail::packed_field_fixed<int32_t>;
+
+/// Class for generating packed repeated fixed64 fields.
 using packed_field_fixed64  = detail::packed_field_fixed<uint64_t>;
+
+/// Class for generating packed repeated sfixed64 fields.
 using packed_field_sfixed64 = detail::packed_field_fixed<int64_t>;
+
+/// Class for generating packed repeated float fields.
 using packed_field_float    = detail::packed_field_fixed<float>;
+
+/// Class for generating packed repeated double fields.
 using packed_field_double   = detail::packed_field_fixed<double>;
 
 } // end namespace protozero