From df92f1a4011eb35e1388f6d4c35e63879e47261c Mon Sep 17 00:00:00 2001 From: rsgowman Date: Fri, 23 Mar 2018 11:20:40 -0400 Subject: 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). --- .../src/firebase/firestore/remote/serializer.cc | 174 ++++++++++----------- 1 file changed, 87 insertions(+), 87 deletions(-) (limited to 'Firestore/core/src') 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& object_value); std::map DecodeObject(pb_istream_t* stream); @@ -45,7 +45,8 @@ std::map 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 { * ____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& encode_message_fn); + void WriteNestedMessage(const std::function& 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* 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(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& encode_message_fn) { +void Writer::WriteNestedMessage( + const std::function& 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 fields = 1; * } - * would be encoded (in proto text format) as: + * would be written (in proto text format) as: * { * fields: {key:"key string 1", value:{}} * fields: {key:"key string 2", value:{}} * ... * } * - * 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& 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 DecodeFieldsEntry(pb_istream_t* stream) { @@ -513,15 +513,15 @@ std::pair DecodeFieldsEntry(pb_istream_t* stream) { return {key, value}; } -void EncodeObject(Writer* stream, +void EncodeObject(Writer* writer, const std::map& 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 DecodeObject(pb_istream_t* stream) { void Serializer::EncodeFieldValue(const FieldValue& field_value, std::vector* 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) { -- cgit v1.2.3