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_H__ 32 #define GOOGLE_PROTOBUF_MAP_ENTRY_H__ 33 34 #include <google/protobuf/generated_message_reflection.h> 35 #include <google/protobuf/map_entry_lite.h> 36 #include <google/protobuf/map_type_handler.h> 37 #include <google/protobuf/port.h> 38 #include <google/protobuf/reflection_ops.h> 39 #include <google/protobuf/unknown_field_set.h> 40 #include <google/protobuf/wire_format_lite.h> 41 42 #include <google/protobuf/port_def.inc> 43 44 #ifdef SWIG 45 #error "You cannot SWIG proto headers" 46 #endif 47 48 namespace google { 49 namespace protobuf { 50 class Arena; 51 namespace internal { 52 template <typename Derived, typename Key, typename Value, 53 WireFormatLite::FieldType kKeyFieldType, 54 WireFormatLite::FieldType kValueFieldType> 55 class MapField; 56 } 57 } // namespace protobuf 58 } // namespace google 59 60 namespace google { 61 namespace protobuf { 62 namespace internal { 63 64 // MapEntry is the returned google::protobuf::Message when calling AddMessage of 65 // google::protobuf::Reflection. In order to let it work with generated message 66 // reflection, its in-memory type is the same as generated message with the same 67 // fields. However, in order to decide the in-memory type of key/value, we need 68 // to know both their cpp type in generated api and proto type. In 69 // implementation, all in-memory types have related wire format functions to 70 // support except ArenaStringPtr. Therefore, we need to define another type with 71 // supporting wire format functions. Since this type is only used as return type 72 // of MapEntry accessors, it's named MapEntry accessor type. 73 // 74 // cpp type: the type visible to users in public API. 75 // proto type: WireFormatLite::FieldType of the field. 76 // in-memory type: type of the data member used to stored this field. 77 // MapEntry accessor type: type used in MapEntry getters/mutators to access the 78 // field. 79 // 80 // cpp type | proto type | in-memory type | MapEntry accessor type 81 // int32 TYPE_INT32 int32 int32 82 // int32 TYPE_FIXED32 int32 int32 83 // string TYPE_STRING ArenaStringPtr string 84 // FooEnum TYPE_ENUM int int 85 // FooMessage TYPE_MESSAGE FooMessage* FooMessage 86 // 87 // The in-memory types of primitive types can be inferred from its proto type, 88 // while we need to explicitly specify the cpp type if proto type is 89 // TYPE_MESSAGE to infer the in-memory type. 90 template <typename Derived, typename Key, typename Value, 91 WireFormatLite::FieldType kKeyFieldType, 92 WireFormatLite::FieldType kValueFieldType> 93 class MapEntry : public MapEntryImpl<Derived, Message, Key, Value, 94 kKeyFieldType, kValueFieldType> { 95 public: MapEntry()96 constexpr MapEntry() : _internal_metadata_() {} MapEntry(Arena * arena)97 explicit MapEntry(Arena* arena) 98 : MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, 99 kValueFieldType>(arena), 100 _internal_metadata_(arena) {} ~MapEntry()101 ~MapEntry() { 102 Message::_internal_metadata_.template Delete<UnknownFieldSet>(); 103 _internal_metadata_.Delete<UnknownFieldSet>(); 104 } 105 typedef void InternalArenaConstructable_; 106 typedef void DestructorSkippable_; 107 108 typedef typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, 109 kValueFieldType>::KeyTypeHandler KeyTypeHandler; 110 typedef 111 typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, 112 kValueFieldType>::ValueTypeHandler ValueTypeHandler; SpaceUsedLong()113 size_t SpaceUsedLong() const override { 114 size_t size = sizeof(Derived); 115 size += KeyTypeHandler::SpaceUsedInMapEntryLong(this->key_); 116 size += ValueTypeHandler::SpaceUsedInMapEntryLong(this->value_); 117 return size; 118 } 119 120 InternalMetadata _internal_metadata_; 121 122 private: 123 friend class ::PROTOBUF_NAMESPACE_ID::Arena; 124 template <typename C, typename K, typename V, 125 WireFormatLite::FieldType k_wire_type, WireFormatLite::FieldType> 126 friend class internal::MapField; 127 128 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry); 129 }; 130 131 // Specialization for the full runtime 132 template <typename Derived, typename Key, typename Value, 133 WireFormatLite::FieldType kKeyFieldType, 134 WireFormatLite::FieldType kValueFieldType> 135 struct MapEntryHelper< 136 MapEntry<Derived, Key, Value, kKeyFieldType, kValueFieldType> > 137 : MapEntryHelper< 138 MapEntryLite<Derived, Key, Value, kKeyFieldType, kValueFieldType> > { 139 explicit MapEntryHelper(const MapPair<Key, Value>& map_pair) 140 : MapEntryHelper< 141 MapEntryLite<Derived, Key, Value, kKeyFieldType, kValueFieldType> >( 142 map_pair) {} 143 }; 144 145 template <typename Derived, typename K, typename V, 146 WireFormatLite::FieldType key, WireFormatLite::FieldType value> 147 struct DeconstructMapEntry<MapEntry<Derived, K, V, key, value> > { 148 typedef K Key; 149 typedef V Value; 150 static constexpr WireFormatLite::FieldType kKeyFieldType = key; 151 static constexpr WireFormatLite::FieldType kValueFieldType = value; 152 }; 153 154 } // namespace internal 155 } // namespace protobuf 156 } // namespace google 157 158 #include <google/protobuf/port_undef.inc> 159 160 #endif // GOOGLE_PROTOBUF_MAP_ENTRY_H__ 161