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, int default_enum_value> 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. Moreover, default_enum_value is 90 // used to initialize enum field in proto2. 91 template <typename Derived, typename Key, typename Value, 92 WireFormatLite::FieldType kKeyFieldType, 93 WireFormatLite::FieldType kValueFieldType, int default_enum_value> 94 class MapEntry 95 : public MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, 96 kValueFieldType, default_enum_value> { 97 public: MapEntry()98 MapEntry() : _internal_metadata_(NULL) {} MapEntry(Arena * arena)99 explicit MapEntry(Arena* arena) 100 : MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, 101 kValueFieldType, default_enum_value>(arena), 102 _internal_metadata_(arena) {} ~MapEntry()103 ~MapEntry() { 104 Message::_internal_metadata_.Delete<UnknownFieldSet>(); 105 _internal_metadata_.Delete<UnknownFieldSet>(); 106 } 107 typedef void InternalArenaConstructable_; 108 typedef void DestructorSkippable_; 109 110 typedef 111 typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, 112 kValueFieldType, default_enum_value>::KeyTypeHandler 113 KeyTypeHandler; 114 typedef typename MapEntryImpl< 115 Derived, Message, Key, Value, kKeyFieldType, kValueFieldType, 116 default_enum_value>::ValueTypeHandler ValueTypeHandler; SpaceUsedLong()117 size_t SpaceUsedLong() const override { 118 size_t size = sizeof(Derived); 119 size += KeyTypeHandler::SpaceUsedInMapEntryLong(this->key_); 120 size += ValueTypeHandler::SpaceUsedInMapEntryLong(this->value_); 121 return size; 122 } 123 124 InternalMetadata _internal_metadata_; 125 126 private: 127 friend class ::PROTOBUF_NAMESPACE_ID::Arena; 128 template <typename C, typename K, typename V, 129 WireFormatLite::FieldType k_wire_type, WireFormatLite::FieldType, 130 int default_enum> 131 friend class internal::MapField; 132 133 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry); 134 }; 135 136 // Specialization for the full runtime 137 template <typename Derived, typename Key, typename Value, 138 WireFormatLite::FieldType kKeyFieldType, 139 WireFormatLite::FieldType kValueFieldType, int default_enum_value> 140 struct MapEntryHelper<MapEntry<Derived, Key, Value, kKeyFieldType, 141 kValueFieldType, default_enum_value> > 142 : MapEntryHelper<MapEntryLite<Derived, Key, Value, kKeyFieldType, 143 kValueFieldType, default_enum_value> > { 144 explicit MapEntryHelper(const MapPair<Key, Value>& map_pair) 145 : MapEntryHelper<MapEntryLite<Derived, Key, Value, kKeyFieldType, 146 kValueFieldType, default_enum_value> >( 147 map_pair) {} 148 }; 149 150 template <typename Derived, typename K, typename V, 151 WireFormatLite::FieldType key, WireFormatLite::FieldType value, 152 int default_enum> 153 struct DeconstructMapEntry<MapEntry<Derived, K, V, key, value, default_enum> > { 154 typedef K Key; 155 typedef V Value; 156 static constexpr WireFormatLite::FieldType kKeyFieldType = key; 157 static constexpr WireFormatLite::FieldType kValueFieldType = value; 158 static constexpr int default_enum_value = default_enum; 159 }; 160 161 } // namespace internal 162 } // namespace protobuf 163 } // namespace google 164 165 #include <google/protobuf/port_undef.inc> 166 167 #endif // GOOGLE_PROTOBUF_MAP_ENTRY_H__ 168