Renames in serializer to reflect recent changes (#957)

* Rename Writer::Encode* methods to Writer::Write*

* Rename: s/stream/writer/ (approximately)

but only where it applies to Writer (rather than pb_ostream_t).

1 files changed, 87 insertions, 87 deletions

diff --git a/Firestore/core/src/firebase/firestore/remote/serializer.cc b/Firestore/core/src/firebase/firestore/remote/serializer.cc
index f7f784a..bab5856 100644
--- a/Firestore/core/src/firebase/firestore/remote/serializer.cc
+++ b/Firestore/core/src/firebase/firestore/remote/serializer.cc
@@ -36,7 +36,7 @@ namespace {
 
 class Writer;
 
-void EncodeObject(Writer* stream,
+void EncodeObject(Writer* writer,
                   const std::map<std::string, FieldValue>& object_value);
 
 std::map<std::string, FieldValue> DecodeObject(pb_istream_t* stream);
@@ -45,7 +45,8 @@ std::map<std::string, FieldValue> DecodeObject(pb_istream_t* stream);
  * Docs TODO(rsgowman). But currently, this just wraps the underlying nanopb
  * pb_ostream_t.
  */
-// TODO(rsgowman): Encode* -> Write*
+// TODO(rsgowman): Define ObjectT alias (in field_value.h) and use it
+// throughout.
 class Writer {
  public:
   /**
@@ -63,12 +64,12 @@ class Writer {
    * Creates a non-writing output stream used to calculate the size of
    * the serialized output.
    */
-  static Writer SizingStream() {
+  static Writer Sizing() {
     return Writer(PB_OSTREAM_SIZING);
   }
 
   /**
-   * Encodes a message type to the output stream.
+   * Writes a message type to the output stream.
    *
    * This essentially wraps calls to nanopb's pb_encode_tag() method.
    *
@@ -77,31 +78,30 @@ class Writer {
    * <parentNameSpace>_<childNameSpace>_<message>_<field>_tag, e.g.
    * google_firestore_v1beta1_Document_name_tag.
    */
-  void EncodeTag(pb_wire_type_t wiretype, uint32_t field_number);
+  void WriteTag(pb_wire_type_t wiretype, uint32_t field_number);
 
-  void EncodeSize(size_t size);
-  void EncodeNull();
-  void EncodeBool(bool bool_value);
-  void EncodeInteger(int64_t integer_value);
+  void WriteSize(size_t size);
+  void WriteNull();
+  void WriteBool(bool bool_value);
+  void WriteInteger(int64_t integer_value);
 
-  void EncodeString(const std::string& string_value);
+  void WriteString(const std::string& string_value);
 
   /**
-   * Encodes a message and its length.
+   * Writes a message and its length.
    *
-   * When encoding a top level message, protobuf doesn't include the length
+   * When writing a top level message, protobuf doesn't include the length
    * (since you can get that already from the length of the binary output.) But
-   * when encoding a sub/nested message, you must include the length in the
+   * when writing a sub/nested message, you must include the length in the
    * serialization.
    *
-   * Call this method when encoding a nested message. Provide a function to
-   * encode the message itself. This method will calculate the size of the
-   * encoded message (using the provided function with a non-writing sizing
+   * Call this method when writing a nested message. Provide a function to
+   * write the message itself. This method will calculate the size of the
+   * written message (using the provided function with a non-writing sizing
    * stream), write out the size (and perform sanity checks), and then serialize
    * the message by calling the provided function a second time.
    */
-  void EncodeNestedMessage(
-      const std::function<void(Writer*)>& encode_message_fn);
+  void WriteNestedMessage(const std::function<void(Writer*)>& write_message_fn);
 
   size_t bytes_written() const {
     return stream_.bytes_written;
@@ -117,7 +117,7 @@ class Writer {
   }
 
   /**
-   * Encodes a "varint" to the output stream.
+   * Writes a "varint" to the output stream.
    *
    * This essentially wraps calls to nanopb's pb_encode_varint() method.
    *
@@ -125,11 +125,11 @@ class Writer {
    * int32, int64, uint32 and uint64 proto field types.
    *
    * Note: This is not expected to be called directly, but rather only
-   * via the other Encode* methods (i.e. EncodeBool, EncodeLong, etc)
+   * via the other Write* methods (i.e. WriteBool, WriteLong, etc)
    *
-   * @param value The value to encode, represented as a uint64_t.
+   * @param value The value to write, represented as a uint64_t.
    */
-  void EncodeVarint(uint64_t value);
+  void WriteVarint(uint64_t value);
 
   pb_ostream_t stream_;
 };
@@ -167,7 +167,7 @@ Writer Writer::Wrap(std::vector<uint8_t>* out_bytes) {
 // make it a bit easier to review. Refactor these to group the related methods
 // together (probably within their own file rather than here).
 
-void Writer::EncodeTag(pb_wire_type_t wiretype, uint32_t field_number) {
+void Writer::WriteTag(pb_wire_type_t wiretype, uint32_t field_number) {
   bool status = pb_encode_tag(&stream_, wiretype, field_number);
   if (!status) {
     // TODO(rsgowman): figure out error handling
@@ -175,11 +175,11 @@ void Writer::EncodeTag(pb_wire_type_t wiretype, uint32_t field_number) {
   }
 }
 
-void Writer::EncodeSize(size_t size) {
-  return EncodeVarint(size);
+void Writer::WriteSize(size_t size) {
+  return WriteVarint(size);
 }
 
-void Writer::EncodeVarint(uint64_t value) {
+void Writer::WriteVarint(uint64_t value) {
   bool status = pb_encode_varint(&stream_, value);
   if (!status) {
     // TODO(rsgowman): figure out error handling
@@ -206,8 +206,8 @@ uint64_t DecodeVarint(pb_istream_t* stream) {
   return varint_value;
 }
 
-void Writer::EncodeNull() {
-  return EncodeVarint(google_protobuf_NullValue_NULL_VALUE);
+void Writer::WriteNull() {
+  return WriteVarint(google_protobuf_NullValue_NULL_VALUE);
 }
 
 void DecodeNull(pb_istream_t* stream) {
@@ -218,8 +218,8 @@ void DecodeNull(pb_istream_t* stream) {
   }
 }
 
-void Writer::EncodeBool(bool bool_value) {
-  return EncodeVarint(bool_value);
+void Writer::WriteBool(bool bool_value) {
+  return WriteVarint(bool_value);
 }
 
 bool DecodeBool(pb_istream_t* stream) {
@@ -235,15 +235,15 @@ bool DecodeBool(pb_istream_t* stream) {
   }
 }
 
-void Writer::EncodeInteger(int64_t integer_value) {
-  return EncodeVarint(integer_value);
+void Writer::WriteInteger(int64_t integer_value) {
+  return WriteVarint(integer_value);
 }
 
 int64_t DecodeInteger(pb_istream_t* stream) {
   return DecodeVarint(stream);
 }
 
-void Writer::EncodeString(const std::string& string_value) {
+void Writer::WriteString(const std::string& string_value) {
   bool status = pb_encode_string(
       &stream_, reinterpret_cast<const pb_byte_t*>(string_value.c_str()),
       string_value.length());
@@ -288,38 +288,38 @@ std::string DecodeString(pb_istream_t* stream) {
 // TODO(rsgowman): Refactor to use a helper class that wraps the stream struct.
 // This will help with error handling, and should eliminate the issue of two
 // 'EncodeFieldValue' methods.
-void EncodeFieldValueImpl(Writer* stream, const FieldValue& field_value) {
+void EncodeFieldValueImpl(Writer* writer, const FieldValue& field_value) {
   // TODO(rsgowman): some refactoring is in order... but will wait until after a
   // non-varint, non-fixed-size (i.e. string) type is present before doing so.
   switch (field_value.type()) {
     case FieldValue::Type::Null:
-      stream->EncodeTag(PB_WT_VARINT,
-                        google_firestore_v1beta1_Value_null_value_tag);
-      stream->EncodeNull();
+      writer->WriteTag(PB_WT_VARINT,
+                       google_firestore_v1beta1_Value_null_value_tag);
+      writer->WriteNull();
       break;
 
     case FieldValue::Type::Boolean:
-      stream->EncodeTag(PB_WT_VARINT,
-                        google_firestore_v1beta1_Value_boolean_value_tag);
-      stream->EncodeBool(field_value.boolean_value());
+      writer->WriteTag(PB_WT_VARINT,
+                       google_firestore_v1beta1_Value_boolean_value_tag);
+      writer->WriteBool(field_value.boolean_value());
       break;
 
     case FieldValue::Type::Integer:
-      stream->EncodeTag(PB_WT_VARINT,
-                        google_firestore_v1beta1_Value_integer_value_tag);
-      stream->EncodeInteger(field_value.integer_value());
+      writer->WriteTag(PB_WT_VARINT,
+                       google_firestore_v1beta1_Value_integer_value_tag);
+      writer->WriteInteger(field_value.integer_value());
       break;
 
     case FieldValue::Type::String:
-      stream->EncodeTag(PB_WT_STRING,
-                        google_firestore_v1beta1_Value_string_value_tag);
-      stream->EncodeString(field_value.string_value());
+      writer->WriteTag(PB_WT_STRING,
+                       google_firestore_v1beta1_Value_string_value_tag);
+      writer->WriteString(field_value.string_value());
       break;
 
     case FieldValue::Type::Object:
-      stream->EncodeTag(PB_WT_STRING,
-                        google_firestore_v1beta1_Value_map_value_tag);
-      EncodeObject(stream, field_value.object_value());
+      writer->WriteTag(PB_WT_STRING,
+                       google_firestore_v1beta1_Value_map_value_tag);
+      EncodeObject(writer, field_value.object_value());
       break;
 
     default:
@@ -379,15 +379,15 @@ FieldValue DecodeFieldValueImpl(pb_istream_t* stream) {
   }
 }
 
-void Writer::EncodeNestedMessage(
-    const std::function<void(Writer*)>& encode_message_fn) {
+void Writer::WriteNestedMessage(
+    const std::function<void(Writer*)>& write_message_fn) {
   // First calculate the message size using a non-writing substream.
-  Writer sizing_substream = Writer::SizingStream();
-  encode_message_fn(&sizing_substream);
-  size_t size = sizing_substream.bytes_written();
+  Writer sizer = Writer::Sizing();
+  write_message_fn(&sizer);
+  size_t size = sizer.bytes_written();
 
-  // Write out the size to the output stream.
-  EncodeSize(size);
+  // Write out the size to the output writer.
+  WriteSize(size);
 
   // If this stream is itself a sizing stream, then we don't need to actually
   // parse field_value a second time; just update the bytes_written via a call
@@ -412,16 +412,16 @@ void Writer::EncodeNestedMessage(
   // did the first time. (Use an initializer rather than setting fields
   // individually like nanopb does. This gives us a *chance* of noticing if
   // nanopb adds new fields.)
-  Writer writing_substream({stream_.callback, stream_.state,
-                            /*max_size=*/size, /*bytes_written=*/0,
-                            /*errmsg=*/nullptr});
-  encode_message_fn(&writing_substream);
+  Writer writer({stream_.callback, stream_.state,
+                 /*max_size=*/size, /*bytes_written=*/0,
+                 /*errmsg=*/nullptr});
+  write_message_fn(&writer);
 
-  stream_.bytes_written += writing_substream.stream_.bytes_written;
-  stream_.state = writing_substream.stream_.state;
-  stream_.errmsg = writing_substream.stream_.errmsg;
+  stream_.bytes_written += writer.stream_.bytes_written;
+  stream_.state = writer.stream_.state;
+  stream_.errmsg = writer.stream_.errmsg;
 
-  if (writing_substream.bytes_written() != size) {
+  if (writer.bytes_written() != size) {
     // submsg size changed
     // TODO(rsgowman): figure out error handling
     abort();
@@ -462,30 +462,30 @@ FieldValue DecodeNestedFieldValue(pb_istream_t* stream) {
  *   message Foo {
  *     map<string, Value> fields = 1;
  *   }
- * would be encoded (in proto text format) as:
+ * would be written (in proto text format) as:
  *   {
  *     fields: {key:"key string 1", value:{<Value message here>}}
  *     fields: {key:"key string 2", value:{<Value message here>}}
  *     ...
  *   }
  *
- * This method encodes an individual entry from that list. It is expected that
+ * This method writes an individual entry from that list. It is expected that
  * this method will be called once for each entry in the map.
  *
- * @param kv The individual key/value pair to encode.
+ * @param kv The individual key/value pair to write.
  */
-void EncodeFieldsEntry(Writer* stream,
+void EncodeFieldsEntry(Writer* writer,
                        const std::pair<std::string, FieldValue>& kv) {
-  // Encode the key (string)
-  stream->EncodeTag(PB_WT_STRING,
-                    google_firestore_v1beta1_MapValue_FieldsEntry_key_tag);
-  stream->EncodeString(kv.first);
-
-  // Encode the value (FieldValue)
-  stream->EncodeTag(PB_WT_STRING,
-                    google_firestore_v1beta1_MapValue_FieldsEntry_value_tag);
-  stream->EncodeNestedMessage(
-      [&kv](Writer* stream) { EncodeFieldValueImpl(stream, kv.second); });
+  // Write the key (string)
+  writer->WriteTag(PB_WT_STRING,
+                   google_firestore_v1beta1_MapValue_FieldsEntry_key_tag);
+  writer->WriteString(kv.first);
+
+  // Write the value (FieldValue)
+  writer->WriteTag(PB_WT_STRING,
+                   google_firestore_v1beta1_MapValue_FieldsEntry_value_tag);
+  writer->WriteNestedMessage(
+      [&kv](Writer* writer) { EncodeFieldValueImpl(writer, kv.second); });
 }
 
 std::pair<std::string, FieldValue> DecodeFieldsEntry(pb_istream_t* stream) {
@@ -513,15 +513,15 @@ std::pair<std::string, FieldValue> DecodeFieldsEntry(pb_istream_t* stream) {
   return {key, value};
 }
 
-void EncodeObject(Writer* stream,
+void EncodeObject(Writer* writer,
                   const std::map<std::string, FieldValue>& object_value) {
-  stream->EncodeNestedMessage([&object_value](Writer* stream) {
-    // Encode each FieldsEntry (i.e. key-value pair.)
+  writer->WriteNestedMessage([&object_value](Writer* writer) {
+    // Write each FieldsEntry (i.e. key-value pair.)
     for (const auto& kv : object_value) {
-      stream->EncodeTag(PB_WT_STRING,
-                        google_firestore_v1beta1_MapValue_FieldsEntry_key_tag);
-      stream->EncodeNestedMessage(
-          [&kv](Writer* stream) { EncodeFieldsEntry(stream, kv); });
+      writer->WriteTag(PB_WT_STRING,
+                       google_firestore_v1beta1_MapValue_FieldsEntry_key_tag);
+      writer->WriteNestedMessage(
+          [&kv](Writer* writer) { EncodeFieldsEntry(writer, kv); });
     }
 
     return true;
@@ -567,8 +567,8 @@ std::map<std::string, FieldValue> DecodeObject(pb_istream_t* stream) {
 
 void Serializer::EncodeFieldValue(const FieldValue& field_value,
                                   std::vector<uint8_t>* out_bytes) {
-  Writer stream = Writer::Wrap(out_bytes);
-  EncodeFieldValueImpl(&stream, field_value);
+  Writer writer = Writer::Wrap(out_bytes);
+  EncodeFieldValueImpl(&writer, field_value);
 }
 
 FieldValue Serializer::DecodeFieldValue(const uint8_t* bytes, size_t length) {