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