1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <nvram/messages/message_codec.h>
18
19namespace nvram {
20namespace proto {
21
22MessageEncoderBase::MessageEncoderBase(const void* object,
23                                       const FieldDescriptor* descriptors,
24                                       size_t num_descriptors)
25    : object_(object),
26      descriptors_(descriptors),
27      num_descriptors_(num_descriptors) {}
28
29bool MessageEncoderBase::Encode(const void* object,
30                                ProtoWriter* writer,
31                                const FieldDescriptor* descriptors,
32                                size_t num_descriptors) {
33  MessageEncoderBase encoder(object, descriptors, num_descriptors);
34  return encoder.Encode(writer);
35}
36
37size_t MessageEncoderBase::GetSize() {
38  CountingOutputStreamBuffer counting_stream;
39  ProtoWriter writer(&counting_stream);
40  return EncodeData(&writer) ? counting_stream.bytes_written() : 0;
41}
42
43bool MessageEncoderBase::Encode(ProtoWriter* writer) {
44  // We need to compute the total size of all struct fields up front in order to
45  // write a length delimiter that designates the end of the encoded nested
46  // message. Note that computing the size of |object| requires a second
47  // |EncodeData()| call in addition to the one that actually encodes the data.
48  // When handling nested message structures, each level triggers its own size
49  // computation, which are redundant with those performed by the levels above.
50  //
51  // For now, we just accept this inefficiency in the interest of keeping things
52  // simple and correct. If this ever becomes a performance problem for deeply
53  // nested structs here are some options:
54  //  * Reserve bytes in |writer| for the encoded size. Once |Encode()|
55  //    completes, it is known how many bytes were required, at which point the
56  //    size field can be updated. The drawback with this solution is that
57  //    varint encoding is variable length, so we'd have to write a degenerated
58  //    varint that may occupy more bytes than actually required.
59  //  * Cache encoded sizes in the struct. This is the solution implemented in
60  //    the regular protobuf implementation. This is relatively straightforward,
61  //    but at the expense of holding data in struct that doesn't really belong
62  //    there.
63  //  * Make a first pass over the struct tree, compute sizes and cache them in
64  //    some auxiliary data structure held in the encoder. This is probably the
65  //    cleanest solution, but comes at the expense of having to thread the size
66  //    cache data structure through the encoding logic.
67  return writer->WriteLengthHeader(GetSize()) && EncodeData(writer);
68}
69
70bool MessageEncoderBase::EncodeData(ProtoWriter* writer) {
71  for (size_t i = 0; i < num_descriptors_; ++i) {
72    const FieldDescriptor& desc = descriptors_[i];
73    writer->set_field_number(desc.field_number);
74    if (!desc.encode_function(object_, writer)) {
75      return false;
76    }
77  }
78
79  return true;
80}
81
82MessageDecoderBase::MessageDecoderBase(void* object,
83                                       const FieldDescriptor* descriptors,
84                                       size_t num_descriptors)
85    : object_(object),
86      descriptors_(descriptors),
87      num_descriptors_(num_descriptors) {}
88
89bool MessageDecoderBase::Decode(void* object,
90                                ProtoReader* reader,
91                                const FieldDescriptor* descriptors,
92                                size_t num_descriptors) {
93  MessageDecoderBase decoder(object, descriptors, num_descriptors);
94  return decoder.Decode(reader);
95}
96
97bool MessageDecoderBase::Decode(ProtoReader* reader) {
98  NestedInputStreamBuffer nested_stream_buffer(reader->stream_buffer(),
99                                               reader->field_size());
100  ProtoReader nested_reader(&nested_stream_buffer);
101  return DecodeData(&nested_reader) && nested_reader.Done();
102}
103
104bool MessageDecoderBase::DecodeData(ProtoReader* reader) {
105  while (!reader->Done()) {
106    if (!reader->ReadWireTag()) {
107      return false;
108    }
109    const FieldDescriptor* desc = FindDescriptor(reader);
110    if (desc) {
111      if (!desc->decode_function(object_, reader)) {
112        return false;
113      }
114    } else {
115      // Unknown field number or wire type mismatch. Skip field data.
116      if (!reader->SkipField()) {
117        return false;
118      }
119    }
120  }
121
122  return true;
123}
124
125const FieldDescriptor* MessageDecoderBase::FindDescriptor(
126    ProtoReader* reader) const {
127  for (size_t i = 0; i < num_descriptors_; ++i) {
128    const FieldDescriptor& desc = descriptors_[i];
129    if (reader->field_number() == desc.field_number &&
130        reader->wire_type() == desc.wire_type) {
131      return &desc;
132    }
133  }
134  return nullptr;
135}
136
137}  // namespace proto
138}  // namespace nvram
139