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_FIELD_INL_H__ 32 #define GOOGLE_PROTOBUF_MAP_FIELD_INL_H__ 33 34 #include <memory> 35 #ifndef _SHARED_PTR_H 36 #include <google/protobuf/stubs/shared_ptr.h> 37 #endif 38 39 #include <google/protobuf/map.h> 40 #include <google/protobuf/map_field.h> 41 #include <google/protobuf/map_type_handler.h> 42 43 namespace google { 44 namespace protobuf { 45 namespace internal { 46 // UnwrapMapKey template 47 template<typename T> 48 T UnwrapMapKey(const MapKey& map_key); 49 template<> 50 inline int32 UnwrapMapKey<int32>(const MapKey& map_key) { 51 return map_key.GetInt32Value(); 52 } 53 template<> 54 inline uint32 UnwrapMapKey<uint32>(const MapKey& map_key) { 55 return map_key.GetUInt32Value(); 56 } 57 template<> 58 inline int64 UnwrapMapKey<int64>(const MapKey& map_key) { 59 return map_key.GetInt64Value(); 60 } 61 template<> 62 inline uint64 UnwrapMapKey<uint64>(const MapKey& map_key) { 63 return map_key.GetUInt64Value(); 64 } 65 template<> 66 inline bool UnwrapMapKey<bool>(const MapKey& map_key) { 67 return map_key.GetBoolValue(); 68 } 69 template<> 70 inline string UnwrapMapKey<string>(const MapKey& map_key) { 71 return map_key.GetStringValue(); 72 } 73 74 // SetMapKey template 75 template<typename T> 76 inline void SetMapKey(MapKey* map_key, const T& value); 77 template<> 78 inline void SetMapKey<int32>(MapKey* map_key, const int32& value) { 79 map_key->SetInt32Value(value); 80 } 81 template<> 82 inline void SetMapKey<uint32>(MapKey* map_key, const uint32& value) { 83 map_key->SetUInt32Value(value); 84 } 85 template<> 86 inline void SetMapKey<int64>(MapKey* map_key, const int64& value) { 87 map_key->SetInt64Value(value); 88 } 89 template<> 90 inline void SetMapKey<uint64>(MapKey* map_key, const uint64& value) { 91 map_key->SetUInt64Value(value); 92 } 93 template<> 94 inline void SetMapKey<bool>(MapKey* map_key, const bool& value) { 95 map_key->SetBoolValue(value); 96 } 97 template<> 98 inline void SetMapKey<string>(MapKey* map_key, const string& value) { 99 map_key->SetStringValue(value); 100 } 101 102 // ------------------------TypeDefinedMapFieldBase--------------- 103 template <typename Key, typename T> 104 typename Map<Key, T>::const_iterator& 105 TypeDefinedMapFieldBase<Key, T>::InternalGetIterator( 106 const MapIterator* map_iter) const { 107 return *reinterpret_cast<typename Map<Key, T>::const_iterator *>( 108 map_iter->iter_); 109 } 110 111 template <typename Key, typename T> 112 void TypeDefinedMapFieldBase<Key, T>::MapBegin(MapIterator* map_iter) const { 113 InternalGetIterator(map_iter) = GetMap().begin(); 114 SetMapIteratorValue(map_iter); 115 } 116 117 template <typename Key, typename T> 118 void TypeDefinedMapFieldBase<Key, T>::MapEnd(MapIterator* map_iter) const { 119 InternalGetIterator(map_iter) = GetMap().end(); 120 } 121 122 template <typename Key, typename T> 123 bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(const MapIterator& a, 124 const MapIterator& b) 125 const { 126 return InternalGetIterator(&a) == InternalGetIterator(&b); 127 } 128 129 template <typename Key, typename T> 130 void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(MapIterator* map_iter) 131 const { 132 ++InternalGetIterator(map_iter); 133 SetMapIteratorValue(map_iter); 134 } 135 136 template <typename Key, typename T> 137 void TypeDefinedMapFieldBase<Key, T>::InitializeIterator( 138 MapIterator* map_iter) const { 139 map_iter->iter_ = new typename Map<Key, T>::const_iterator; 140 GOOGLE_CHECK(map_iter->iter_ != NULL); 141 } 142 143 template <typename Key, typename T> 144 void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(MapIterator* map_iter) 145 const { 146 delete reinterpret_cast<typename Map<Key, T>::const_iterator *>( 147 map_iter->iter_); 148 } 149 150 template <typename Key, typename T> 151 void TypeDefinedMapFieldBase<Key, T>::CopyIterator( 152 MapIterator* this_iter, 153 const MapIterator& that_iter) const { 154 InternalGetIterator(this_iter) = InternalGetIterator(&that_iter); 155 this_iter->key_.SetType(that_iter.key_.type()); 156 // MapValueRef::type() fails when containing data is null. However, if 157 // this_iter points to MapEnd, data can be null. 158 this_iter->value_.SetType( 159 static_cast<FieldDescriptor::CppType>(that_iter.value_.type_)); 160 SetMapIteratorValue(this_iter); 161 } 162 163 // ---------------------------------------------------------------------- 164 165 template <typename Key, typename T, 166 WireFormatLite::FieldType kKeyFieldType, 167 WireFormatLite::FieldType kValueFieldType, 168 int default_enum_value> 169 MapField<Key, T, kKeyFieldType, kValueFieldType, default_enum_value>::MapField() 170 : default_entry_(NULL) {} 171 172 template <typename Key, typename T, 173 WireFormatLite::FieldType kKeyFieldType, 174 WireFormatLite::FieldType kValueFieldType, 175 int default_enum_value> 176 MapField<Key, T, kKeyFieldType, kValueFieldType, default_enum_value>::MapField( 177 Arena* arena) 178 : TypeDefinedMapFieldBase<Key, T>(arena), 179 MapFieldLite<Key, T, kKeyFieldType, kValueFieldType, default_enum_value>( 180 arena), 181 default_entry_(NULL) {} 182 183 template <typename Key, typename T, 184 WireFormatLite::FieldType kKeyFieldType, 185 WireFormatLite::FieldType kValueFieldType, 186 int default_enum_value> 187 MapField<Key, T, kKeyFieldType, kValueFieldType, default_enum_value>::MapField( 188 const Message* default_entry) 189 : default_entry_(down_cast<const EntryType*>(default_entry)) {} 190 191 template <typename Key, typename T, 192 WireFormatLite::FieldType kKeyFieldType, 193 WireFormatLite::FieldType kValueFieldType, 194 int default_enum_value> 195 MapField<Key, T, kKeyFieldType, kValueFieldType, default_enum_value>::MapField( 196 Arena* arena, const Message* default_entry) 197 : TypeDefinedMapFieldBase<Key, T>(arena), 198 MapFieldLite<Key, T, kKeyFieldType, kValueFieldType, default_enum_value>( 199 arena), 200 default_entry_(down_cast<const EntryType*>(default_entry)) {} 201 202 template <typename Key, typename T, 203 WireFormatLite::FieldType kKeyFieldType, 204 WireFormatLite::FieldType kValueFieldType, 205 int default_enum_value> 206 MapField<Key, T, kKeyFieldType, kValueFieldType, 207 default_enum_value>::~MapField() {} 208 209 template <typename Key, typename T, 210 WireFormatLite::FieldType kKeyFieldType, 211 WireFormatLite::FieldType kValueFieldType, 212 int default_enum_value> 213 int 214 MapField<Key, T, kKeyFieldType, kValueFieldType, 215 default_enum_value>::size() const { 216 MapFieldBase::SyncMapWithRepeatedField(); 217 return MapFieldLiteType::GetInternalMap().size(); 218 } 219 220 template <typename Key, typename T, 221 WireFormatLite::FieldType kKeyFieldType, 222 WireFormatLite::FieldType kValueFieldType, 223 int default_enum_value> 224 void 225 MapField<Key, T, kKeyFieldType, kValueFieldType, 226 default_enum_value>::Clear() { 227 MapFieldBase::SyncMapWithRepeatedField(); 228 MapFieldLiteType::MutableInternalMap()->clear(); 229 MapFieldBase::SetMapDirty(); 230 } 231 232 template <typename Key, typename T, 233 WireFormatLite::FieldType kKeyFieldType, 234 WireFormatLite::FieldType kValueFieldType, 235 int default_enum_value> 236 void MapField<Key, T, kKeyFieldType, kValueFieldType, 237 default_enum_value>::SetMapIteratorValue( 238 MapIterator* map_iter) const { 239 const Map<Key, T>& map = GetMap(); 240 typename Map<Key, T>::const_iterator iter = 241 TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(map_iter); 242 if (iter == map.end()) return; 243 SetMapKey(&map_iter->key_, iter->first); 244 map_iter->value_.SetValue(&iter->second); 245 } 246 247 template <typename Key, typename T, 248 WireFormatLite::FieldType kKeyFieldType, 249 WireFormatLite::FieldType kValueFieldType, 250 int default_enum_value> 251 bool MapField<Key, T, kKeyFieldType, kValueFieldType, 252 default_enum_value>::ContainsMapKey( 253 const MapKey& map_key) const { 254 const Map<Key, T>& map = GetMap(); 255 const Key& key = UnwrapMapKey<Key>(map_key); 256 typename Map<Key, T>::const_iterator iter = map.find(key); 257 return iter != map.end(); 258 } 259 260 template <typename Key, typename T, 261 WireFormatLite::FieldType kKeyFieldType, 262 WireFormatLite::FieldType kValueFieldType, 263 int default_enum_value> 264 bool MapField<Key, T, kKeyFieldType, kValueFieldType, 265 default_enum_value>::InsertOrLookupMapValue( 266 const MapKey& map_key, 267 MapValueRef* val) { 268 // Always use mutable map because users may change the map value by 269 // MapValueRef. 270 Map<Key, T>* map = MutableMap(); 271 const Key& key = UnwrapMapKey<Key>(map_key); 272 typename Map<Key, T>::iterator iter = map->find(key); 273 if (map->end() == iter) { 274 val->SetValue(&((*map)[key])); 275 return true; 276 } 277 // Key is already in the map. Make sure (*map)[key] is not called. 278 // [] may reorder the map and iterators. 279 val->SetValue(&(iter->second)); 280 return false; 281 } 282 283 template <typename Key, typename T, 284 WireFormatLite::FieldType kKeyFieldType, 285 WireFormatLite::FieldType kValueFieldType, 286 int default_enum_value> 287 bool MapField<Key, T, kKeyFieldType, kValueFieldType, 288 default_enum_value>::DeleteMapValue( 289 const MapKey& map_key) { 290 const Key& key = UnwrapMapKey<Key>(map_key); 291 return MutableMap()->erase(key); 292 } 293 294 template <typename Key, typename T, 295 WireFormatLite::FieldType kKeyFieldType, 296 WireFormatLite::FieldType kValueFieldType, 297 int default_enum_value> 298 const Map<Key, T>& 299 MapField<Key, T, kKeyFieldType, kValueFieldType, 300 default_enum_value>::GetMap() const { 301 MapFieldBase::SyncMapWithRepeatedField(); 302 return MapFieldLiteType::GetInternalMap(); 303 } 304 305 template <typename Key, typename T, 306 WireFormatLite::FieldType kKeyFieldType, 307 WireFormatLite::FieldType kValueFieldType, 308 int default_enum_value> 309 Map<Key, T>* 310 MapField<Key, T, kKeyFieldType, kValueFieldType, 311 default_enum_value>::MutableMap() { 312 MapFieldBase::SyncMapWithRepeatedField(); 313 Map<Key, T>* result = MapFieldLiteType::MutableInternalMap(); 314 MapFieldBase::SetMapDirty(); 315 return result; 316 } 317 318 template <typename Key, typename T, 319 WireFormatLite::FieldType kKeyFieldType, 320 WireFormatLite::FieldType kValueFieldType, 321 int default_enum_value> 322 void 323 MapField<Key, T, kKeyFieldType, kValueFieldType, 324 default_enum_value>::MergeFrom( 325 const MapFieldLiteType& other) { 326 const MapField& down_other = down_cast<const MapField&>(other); 327 MapFieldBase::SyncMapWithRepeatedField(); 328 down_other.SyncMapWithRepeatedField(); 329 MapFieldLiteType::MergeFrom(other); 330 MapFieldBase::SetMapDirty(); 331 } 332 333 template <typename Key, typename T, 334 WireFormatLite::FieldType kKeyFieldType, 335 WireFormatLite::FieldType kValueFieldType, 336 int default_enum_value> 337 void 338 MapField<Key, T, kKeyFieldType, kValueFieldType, 339 default_enum_value>::Swap( 340 MapFieldLiteType* other) { 341 MapField* down_other = down_cast<MapField*>(other); 342 std::swap(MapFieldBase::repeated_field_, down_other->repeated_field_); 343 MapFieldLiteType::Swap(other); 344 std::swap(MapFieldBase::state_, down_other->state_); 345 } 346 347 template <typename Key, typename T, 348 WireFormatLite::FieldType kKeyFieldType, 349 WireFormatLite::FieldType kValueFieldType, 350 int default_enum_value> 351 void 352 MapField<Key, T, kKeyFieldType, kValueFieldType, 353 default_enum_value>::SetEntryDescriptor( 354 const Descriptor** descriptor) { 355 MapFieldBase::entry_descriptor_ = descriptor; 356 } 357 358 template <typename Key, typename T, 359 WireFormatLite::FieldType kKeyFieldType, 360 WireFormatLite::FieldType kValueFieldType, 361 int default_enum_value> 362 void 363 MapField<Key, T, kKeyFieldType, kValueFieldType, 364 default_enum_value>::SetAssignDescriptorCallback(void (*callback)()) { 365 MapFieldBase::assign_descriptor_callback_ = callback; 366 } 367 368 template <typename Key, typename T, 369 WireFormatLite::FieldType kKeyFieldType, 370 WireFormatLite::FieldType kValueFieldType, 371 int default_enum_value> 372 const Map<Key, T>& 373 MapField<Key, T, kKeyFieldType, kValueFieldType, 374 default_enum_value>::GetInternalMap() const { 375 return MapFieldLiteType::GetInternalMap(); 376 } 377 378 template <typename Key, typename T, 379 WireFormatLite::FieldType kKeyFieldType, 380 WireFormatLite::FieldType kValueFieldType, 381 int default_enum_value> 382 Map<Key, T>* 383 MapField<Key, T, kKeyFieldType, kValueFieldType, 384 default_enum_value>::MutableInternalMap() { 385 return MapFieldLiteType::MutableInternalMap(); 386 } 387 388 template <typename Key, typename T, 389 WireFormatLite::FieldType kKeyFieldType, 390 WireFormatLite::FieldType kValueFieldType, 391 int default_enum_value> 392 void 393 MapField<Key, T, kKeyFieldType, kValueFieldType, 394 default_enum_value>::SyncRepeatedFieldWithMapNoLock() const { 395 if (MapFieldBase::repeated_field_ == NULL) { 396 if (MapFieldBase::arena_ == NULL) { 397 MapFieldBase::repeated_field_ = new RepeatedPtrField<Message>(); 398 } else { 399 MapFieldBase::repeated_field_ = 400 Arena::CreateMessage<RepeatedPtrField<Message> >( 401 MapFieldBase::arena_); 402 } 403 } 404 const Map<Key, T>& map = GetInternalMap(); 405 RepeatedPtrField<EntryType>* repeated_field = 406 reinterpret_cast<RepeatedPtrField<EntryType>*>( 407 MapFieldBase::repeated_field_); 408 409 repeated_field->Clear(); 410 411 for (typename Map<Key, T>::const_iterator it = map.begin(); 412 it != map.end(); ++it) { 413 InitDefaultEntryOnce(); 414 GOOGLE_CHECK(default_entry_ != NULL); 415 EntryType* new_entry = 416 down_cast<EntryType*>(default_entry_->New(MapFieldBase::arena_)); 417 repeated_field->AddAllocated(new_entry); 418 (*new_entry->mutable_key()) = it->first; 419 (*new_entry->mutable_value()) = it->second; 420 } 421 } 422 423 template <typename Key, typename T, 424 WireFormatLite::FieldType kKeyFieldType, 425 WireFormatLite::FieldType kValueFieldType, 426 int default_enum_value> 427 void 428 MapField<Key, T, kKeyFieldType, kValueFieldType, 429 default_enum_value>::SyncMapWithRepeatedFieldNoLock() const { 430 Map<Key, T>* map = const_cast<MapField*>(this)->MutableInternalMap(); 431 RepeatedPtrField<EntryType>* repeated_field = 432 reinterpret_cast<RepeatedPtrField<EntryType>*>( 433 MapFieldBase::repeated_field_); 434 GOOGLE_CHECK(MapFieldBase::repeated_field_ != NULL); 435 map->clear(); 436 for (typename RepeatedPtrField<EntryType>::iterator it = 437 repeated_field->begin(); it != repeated_field->end(); ++it) { 438 // Cast is needed because Map's api and internal storage is different when 439 // value is enum. For enum, we cannot cast an int to enum. Thus, we have to 440 // copy value. For other types, they have same exposed api type and internal 441 // stored type. We should not introduce value copy for them. We achieve this 442 // by casting to value for enum while casting to reference for other types. 443 (*map)[it->key()] = static_cast<CastValueType>(it->value()); 444 } 445 } 446 447 template <typename Key, typename T, 448 WireFormatLite::FieldType kKeyFieldType, 449 WireFormatLite::FieldType kValueFieldType, 450 int default_enum_value> 451 int 452 MapField<Key, T, kKeyFieldType, kValueFieldType, 453 default_enum_value>::SpaceUsedExcludingSelfNoLock() const { 454 int size = 0; 455 if (MapFieldBase::repeated_field_ != NULL) { 456 size += MapFieldBase::repeated_field_->SpaceUsedExcludingSelf(); 457 } 458 Map<Key, T>* map = const_cast<MapField*>(this)->MutableInternalMap(); 459 size += sizeof(*map); 460 for (typename Map<Key, T>::iterator it = map->begin(); 461 it != map->end(); ++it) { 462 size += KeyTypeHandler::SpaceUsedInMap(it->first); 463 size += ValueTypeHandler::SpaceUsedInMap(it->second); 464 } 465 return size; 466 } 467 468 template <typename Key, typename T, 469 WireFormatLite::FieldType kKeyFieldType, 470 WireFormatLite::FieldType kValueFieldType, 471 int default_enum_value> 472 void 473 MapField<Key, T, kKeyFieldType, kValueFieldType, 474 default_enum_value>::InitDefaultEntryOnce() 475 const { 476 if (default_entry_ == NULL) { 477 MapFieldBase::InitMetadataOnce(); 478 GOOGLE_CHECK(*MapFieldBase::entry_descriptor_ != NULL); 479 default_entry_ = down_cast<const EntryType*>( 480 MessageFactory::generated_factory()->GetPrototype( 481 *MapFieldBase::entry_descriptor_)); 482 } 483 } 484 485 } // namespace internal 486 } // namespace protobuf 487 488 } // namespace google 489 #endif // GOOGLE_PROTOBUF_MAP_FIELD_INL_H__ 490
