• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc.  All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 //     * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 //     * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 //     * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 #ifndef GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
32 #define GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
33 
34 #include <google/protobuf/map_type_handler.h>
35 #include <google/protobuf/wire_format_lite_inl.h>
36 
37 namespace google {
38 namespace protobuf {
39 class Arena;
40 namespace internal {
41 template <typename Key, typename Value,
42           WireFormatLite::FieldType kKeyFieldType,
43           WireFormatLite::FieldType kValueFieldType,
44           int default_enum_value>
45 class MapEntry;
46 template <typename Key, typename Value,
47           WireFormatLite::FieldType kKeyFieldType,
48           WireFormatLite::FieldType kValueFieldType,
49           int default_enum_value>
50 class MapFieldLite;
51 }  // namespace internal
52 }  // namespace protobuf
53 
54 namespace protobuf {
55 namespace internal {
56 
57 // MapEntryLite is used to implement parsing and serialization of map for lite
58 // runtime.
59 template <typename Key, typename Value,
60           WireFormatLite::FieldType kKeyFieldType,
61           WireFormatLite::FieldType kValueFieldType,
62           int default_enum_value>
63 class MapEntryLite : public MessageLite {
64   // Provide utilities to parse/serialize key/value.  Provide utilities to
65   // manipulate internal stored type.
66   typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
67   typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
68 
69   // Define internal memory layout. Strings and messages are stored as
70   // pointers, while other types are stored as values.
71   typedef typename KeyTypeHandler::TypeOnMemory KeyOnMemory;
72   typedef typename ValueTypeHandler::TypeOnMemory ValueOnMemory;
73 
74   // Enum type cannot be used for MapTypeHandler::Read. Define a type
75   // which will replace Enum with int.
76   typedef typename KeyTypeHandler::MapEntryAccessorType KeyMapEntryAccessorType;
77   typedef typename ValueTypeHandler::MapEntryAccessorType
78       ValueMapEntryAccessorType;
79 
80   // Constants for field number.
81   static const int kKeyFieldNumber = 1;
82   static const int kValueFieldNumber = 2;
83 
84   // Constants for field tag.
85   static const uint8 kKeyTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
86       kKeyFieldNumber, KeyTypeHandler::kWireType);
87   static const uint8 kValueTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
88       kValueFieldNumber, ValueTypeHandler::kWireType);
89   static const int kTagSize = 1;
90 
91  public:
~MapEntryLite()92   ~MapEntryLite() {
93     if (this != default_instance_) {
94       if (GetArenaNoVirtual() != NULL) return;
95       KeyTypeHandler::DeleteNoArena(key_);
96       ValueTypeHandler::DeleteNoArena(value_);
97     }
98   }
99 
100   // accessors ======================================================
101 
key()102   virtual inline const KeyMapEntryAccessorType& key() const {
103     return KeyTypeHandler::GetExternalReference(key_);
104   }
value()105   virtual inline const ValueMapEntryAccessorType& value() const {
106     GOOGLE_CHECK(default_instance_ != NULL);
107     return ValueTypeHandler::DefaultIfNotInitialized(value_,
108                                                     default_instance_->value_);
109   }
mutable_key()110   inline KeyMapEntryAccessorType* mutable_key() {
111     set_has_key();
112     return KeyTypeHandler::EnsureMutable(&key_, GetArenaNoVirtual());
113   }
mutable_value()114   inline ValueMapEntryAccessorType* mutable_value() {
115     set_has_value();
116     return ValueTypeHandler::EnsureMutable(&value_, GetArenaNoVirtual());
117   }
118 
119   // implements MessageLite =========================================
120 
121   // MapEntryLite is for implementation only and this function isn't called
122   // anywhere. Just provide a fake implementation here for MessageLite.
GetTypeName()123   string GetTypeName() const { return ""; }
124 
CheckTypeAndMergeFrom(const MessageLite & other)125   void CheckTypeAndMergeFrom(const MessageLite& other) {
126     MergeFrom(*::google::protobuf::down_cast<const MapEntryLite*>(&other));
127   }
128 
MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream * input)129   bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream* input) {
130     uint32 tag;
131 
132     for (;;) {
133       // 1) corrupted data: return false;
134       // 2) unknown field: skip without putting into unknown field set;
135       // 3) unknown enum value: keep it in parsing. In proto2, caller should
136       // check the value and put this entry into containing message's unknown
137       // field set if the value is an unknown enum. In proto3, caller doesn't
138       // need to care whether the value is unknown enum;
139       // 4) missing key/value: missed key/value will have default value. caller
140       // should take this entry as if key/value is set to default value.
141       tag = input->ReadTag();
142       switch (tag) {
143         case kKeyTag:
144           if (!KeyTypeHandler::Read(input, mutable_key())) {
145             return false;
146           }
147           set_has_key();
148           if (!input->ExpectTag(kValueTag)) break;
149           GOOGLE_FALLTHROUGH_INTENDED;
150 
151         case kValueTag:
152           if (!ValueTypeHandler::Read(input, mutable_value())) {
153             return false;
154           }
155           set_has_value();
156           if (input->ExpectAtEnd()) return true;
157           break;
158 
159         default:
160           if (tag == 0 ||
161               WireFormatLite::GetTagWireType(tag) ==
162               WireFormatLite::WIRETYPE_END_GROUP) {
163             return true;
164           }
165           if (!WireFormatLite::SkipField(input, tag)) return false;
166           break;
167       }
168     }
169   }
170 
ByteSize()171   int ByteSize() const {
172     int size = 0;
173     size += has_key() ? kTagSize + KeyTypeHandler::ByteSize(key()) : 0;
174     size += has_value() ? kTagSize + ValueTypeHandler::ByteSize(value()) : 0;
175     return size;
176   }
177 
SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream * output)178   void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream* output) const {
179     KeyTypeHandler::Write(kKeyFieldNumber, key(), output);
180     ValueTypeHandler::Write(kValueFieldNumber, value(), output);
181   }
182 
SerializeWithCachedSizesToArray(::google::protobuf::uint8 * output)183   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
184     output = KeyTypeHandler::WriteToArray(kKeyFieldNumber, key(), output);
185     output = ValueTypeHandler::WriteToArray(kValueFieldNumber, value(), output);
186     return output;
187   }
188 
GetCachedSize()189   int GetCachedSize() const {
190     int size = 0;
191     size += has_key()
192         ? kTagSize + KeyTypeHandler::GetCachedSize(key())
193         : 0;
194     size += has_value()
195         ? kTagSize + ValueTypeHandler::GetCachedSize(
196             value())
197         : 0;
198     return size;
199   }
200 
IsInitialized()201   bool IsInitialized() const { return ValueTypeHandler::IsInitialized(value_); }
202 
New()203   MessageLite* New() const {
204     MapEntryLite* entry = new MapEntryLite;
205     entry->default_instance_ = default_instance_;
206     return entry;
207   }
208 
New(Arena * arena)209   MessageLite* New(Arena* arena) const {
210     MapEntryLite* entry = Arena::CreateMessage<MapEntryLite>(arena);
211     entry->default_instance_ = default_instance_;
212     return entry;
213   }
214 
SpaceUsed()215   int SpaceUsed() const {
216     int size = sizeof(MapEntryLite);
217     size += KeyTypeHandler::SpaceUsedInMapEntry(key_);
218     size += ValueTypeHandler::SpaceUsedInMapEntry(value_);
219     return size;
220   }
221 
MergeFrom(const MapEntryLite & from)222   void MergeFrom(const MapEntryLite& from) {
223     if (from._has_bits_[0]) {
224       if (from.has_key()) {
225         KeyTypeHandler::EnsureMutable(&key_, GetArenaNoVirtual());
226         KeyTypeHandler::Merge(from.key(), &key_, GetArenaNoVirtual());
227         set_has_key();
228       }
229       if (from.has_value()) {
230         ValueTypeHandler::EnsureMutable(&value_, GetArenaNoVirtual());
231         ValueTypeHandler::Merge(from.value(), &value_, GetArenaNoVirtual());
232         set_has_value();
233       }
234     }
235   }
236 
Clear()237   void Clear() {
238     KeyTypeHandler::Clear(&key_, GetArenaNoVirtual());
239     ValueTypeHandler::ClearMaybeByDefaultEnum(
240         &value_, GetArenaNoVirtual(), default_enum_value);
241     clear_has_key();
242     clear_has_value();
243   }
244 
InitAsDefaultInstance()245   void InitAsDefaultInstance() {
246     KeyTypeHandler::AssignDefaultValue(&key_);
247     ValueTypeHandler::AssignDefaultValue(&value_);
248   }
249 
GetArena()250   Arena* GetArena() const {
251     return GetArenaNoVirtual();
252   }
253 
254   // Create a MapEntryLite for given key and value from google::protobuf::Map in
255   // serialization. This function is only called when value is enum. Enum is
256   // treated differently because its type in MapEntry is int and its type in
257   // google::protobuf::Map is enum. We cannot create a reference to int from an enum.
EnumWrap(const Key & key,const Value value,Arena * arena)258   static MapEntryLite* EnumWrap(const Key& key, const Value value,
259                                 Arena* arena) {
260     return Arena::CreateMessage<MapEnumEntryWrapper<
261         Key, Value, kKeyFieldType, kValueFieldType, default_enum_value> >(
262         arena, key, value);
263   }
264 
265   // Like above, but for all the other types. This avoids value copy to create
266   // MapEntryLite from google::protobuf::Map in serialization.
Wrap(const Key & key,const Value & value,Arena * arena)267   static MapEntryLite* Wrap(const Key& key, const Value& value, Arena* arena) {
268     return Arena::CreateMessage<MapEntryWrapper<Key, Value, kKeyFieldType,
269                                                 kValueFieldType,
270                                                 default_enum_value> >(
271         arena, key, value);
272   }
273 
274  protected:
set_has_key()275   void set_has_key() { _has_bits_[0] |= 0x00000001u; }
has_key()276   bool has_key() const { return (_has_bits_[0] & 0x00000001u) != 0; }
clear_has_key()277   void clear_has_key() { _has_bits_[0] &= ~0x00000001u; }
set_has_value()278   void set_has_value() { _has_bits_[0] |= 0x00000002u; }
has_value()279   bool has_value() const { return (_has_bits_[0] & 0x00000002u) != 0; }
clear_has_value()280   void clear_has_value() { _has_bits_[0] &= ~0x00000002u; }
281 
282  private:
283   // Serializing a generated message containing map field involves serializing
284   // key-value pairs from google::protobuf::Map. The wire format of each key-value pair
285   // after serialization should be the same as that of a MapEntry message
286   // containing the same key and value inside it.  However, google::protobuf::Map doesn't
287   // store key and value as MapEntry message, which disables us to use existing
288   // code to serialize message. In order to use existing code to serialize
289   // message, we need to construct a MapEntry from key-value pair. But it
290   // involves copy of key and value to construct a MapEntry. In order to avoid
291   // this copy in constructing a MapEntry, we need the following class which
292   // only takes references of given key and value.
293   template <typename K, typename V, WireFormatLite::FieldType k_wire_type,
294             WireFormatLite::FieldType v_wire_type, int default_enum>
295   class MapEntryWrapper
296       : public MapEntryLite<K, V, k_wire_type, v_wire_type, default_enum> {
297     typedef MapEntryLite<K, V, k_wire_type, v_wire_type, default_enum> Base;
298     typedef typename Base::KeyMapEntryAccessorType KeyMapEntryAccessorType;
299     typedef typename Base::ValueMapEntryAccessorType ValueMapEntryAccessorType;
300 
301    public:
MapEntryWrapper(Arena * arena,const K & key,const V & value)302     MapEntryWrapper(Arena* arena, const K& key, const V& value)
303         : MapEntryLite<K, V, k_wire_type, v_wire_type, default_enum>(arena),
304           key_(key),
305           value_(value) {
306       Base::set_has_key();
307       Base::set_has_value();
308     }
key()309     inline const KeyMapEntryAccessorType& key() const { return key_; }
value()310     inline const ValueMapEntryAccessorType& value() const { return value_; }
311 
312    private:
313     const Key& key_;
314     const Value& value_;
315 
316     friend class ::google::protobuf::Arena;
317     typedef void InternalArenaConstructable_;
318     typedef void DestructorSkippable_;
319   };
320 
321   // Like above, but for enum value only, which stores value instead of
322   // reference of value field inside. This is needed because the type of value
323   // field in constructor is an enum, while we need to store it as an int. If we
324   // initialize a reference to int with a reference to enum, compiler will
325   // generate a temporary int from enum and initialize the reference to int with
326   // the temporary.
327   template <typename K, typename V, WireFormatLite::FieldType k_wire_type,
328             WireFormatLite::FieldType v_wire_type, int default_enum>
329   class MapEnumEntryWrapper
330       : public MapEntryLite<K, V, k_wire_type, v_wire_type, default_enum> {
331     typedef MapEntryLite<K, V, k_wire_type, v_wire_type, default_enum> Base;
332     typedef typename Base::KeyMapEntryAccessorType KeyMapEntryAccessorType;
333     typedef typename Base::ValueMapEntryAccessorType ValueMapEntryAccessorType;
334 
335    public:
MapEnumEntryWrapper(Arena * arena,const K & key,const V & value)336     MapEnumEntryWrapper(Arena* arena, const K& key, const V& value)
337         : MapEntryLite<K, V, k_wire_type, v_wire_type, default_enum>(arena),
338           key_(key),
339           value_(value) {
340       Base::set_has_key();
341       Base::set_has_value();
342     }
key()343     inline const KeyMapEntryAccessorType& key() const { return key_; }
value()344     inline const ValueMapEntryAccessorType& value() const { return value_; }
345 
346    private:
347     const KeyMapEntryAccessorType& key_;
348     const ValueMapEntryAccessorType value_;
349 
350     friend class google::protobuf::Arena;
351     typedef void DestructorSkippable_;
352   };
353 
MapEntryLite()354   MapEntryLite() : default_instance_(NULL), arena_(NULL) {
355     KeyTypeHandler::Initialize(&key_, NULL);
356     ValueTypeHandler::InitializeMaybeByDefaultEnum(
357         &value_, default_enum_value, NULL);
358     _has_bits_[0] = 0;
359   }
360 
MapEntryLite(Arena * arena)361   explicit MapEntryLite(Arena* arena)
362       : default_instance_(NULL), arena_(arena) {
363     KeyTypeHandler::Initialize(&key_, arena);
364     ValueTypeHandler::InitializeMaybeByDefaultEnum(
365         &value_, default_enum_value, arena);
366     _has_bits_[0] = 0;
367   }
368 
GetArenaNoVirtual()369   inline Arena* GetArenaNoVirtual() const {
370     return arena_;
371   }
372 
set_default_instance(MapEntryLite * default_instance)373   void set_default_instance(MapEntryLite* default_instance) {
374     default_instance_ = default_instance;
375   }
376 
377   MapEntryLite* default_instance_;
378 
379   KeyOnMemory key_;
380   ValueOnMemory value_;
381   Arena* arena_;
382   uint32 _has_bits_[1];
383 
384   friend class ::google::protobuf::Arena;
385   typedef void InternalArenaConstructable_;
386   typedef void DestructorSkippable_;
387   template <typename K, typename V, WireFormatLite::FieldType,
388             WireFormatLite::FieldType, int>
389   friend class internal::MapEntry;
390   template <typename K, typename V, WireFormatLite::FieldType,
391             WireFormatLite::FieldType, int>
392   friend class internal::MapFieldLite;
393 
394   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryLite);
395 };
396 
397 }  // namespace internal
398 }  // namespace protobuf
399 
400 }  // namespace google
401 #endif  // GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
402