update code
This commit is contained in:
838
include/google/protobuf/map_field.h
Normal file
838
include/google/protobuf/map_field.h
Normal file
@@ -0,0 +1,838 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_MAP_FIELD_H__
|
||||
#define GOOGLE_PROTOBUF_MAP_FIELD_H__
|
||||
|
||||
#include <google/protobuf/stubs/atomicops.h>
|
||||
#include <google/protobuf/stubs/mutex.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/generated_message_reflection.h>
|
||||
#include <google/protobuf/arena.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/map_entry.h>
|
||||
#include <google/protobuf/map_field_lite.h>
|
||||
#include <google/protobuf/map_type_handler.h>
|
||||
#include <google/protobuf/message.h>
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
#include <google/protobuf/unknown_field_set.h>
|
||||
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
class DynamicMessage;
|
||||
class MapKey;
|
||||
namespace internal {
|
||||
|
||||
class ContendedMapCleanTest;
|
||||
class GeneratedMessageReflection;
|
||||
class MapFieldAccessor;
|
||||
|
||||
// This class provides access to map field using reflection, which is the same
|
||||
// as those provided for RepeatedPtrField<Message>. It is used for internal
|
||||
// reflection implentation only. Users should never use this directly.
|
||||
class LIBPROTOBUF_EXPORT MapFieldBase {
|
||||
public:
|
||||
MapFieldBase()
|
||||
: arena_(NULL),
|
||||
repeated_field_(NULL),
|
||||
state_(STATE_MODIFIED_MAP) {}
|
||||
explicit MapFieldBase(Arena* arena)
|
||||
: arena_(arena),
|
||||
repeated_field_(NULL),
|
||||
state_(STATE_MODIFIED_MAP) {
|
||||
// Mutex's destructor needs to be called explicitly to release resources
|
||||
// acquired in its constructor.
|
||||
arena->OwnDestructor(&mutex_);
|
||||
}
|
||||
virtual ~MapFieldBase();
|
||||
|
||||
// Returns reference to internal repeated field. Data written using
|
||||
// google::protobuf::Map's api prior to calling this function is guarantted to be
|
||||
// included in repeated field.
|
||||
const RepeatedPtrFieldBase& GetRepeatedField() const;
|
||||
|
||||
// Like above. Returns mutable pointer to the internal repeated field.
|
||||
RepeatedPtrFieldBase* MutableRepeatedField();
|
||||
|
||||
// Pure virtual map APIs for Map Reflection.
|
||||
virtual bool ContainsMapKey(const MapKey& map_key) const = 0;
|
||||
virtual bool InsertOrLookupMapValue(
|
||||
const MapKey& map_key, MapValueRef* val) = 0;
|
||||
// Insures operations after won't get executed before calling this.
|
||||
bool IsMapValid() const;
|
||||
virtual bool DeleteMapValue(const MapKey& map_key) = 0;
|
||||
virtual bool EqualIterator(const MapIterator& a,
|
||||
const MapIterator& b) const = 0;
|
||||
virtual void MapBegin(MapIterator* map_iter) const = 0;
|
||||
virtual void MapEnd(MapIterator* map_iter) const = 0;
|
||||
// Sync Map with repeated field and returns the size of map.
|
||||
virtual int size() const = 0;
|
||||
|
||||
// Returns the number of bytes used by the repeated field, excluding
|
||||
// sizeof(*this)
|
||||
size_t SpaceUsedExcludingSelfLong() const;
|
||||
|
||||
int SpaceUsedExcludingSelf() const {
|
||||
return internal::ToIntSize(SpaceUsedExcludingSelfLong());
|
||||
}
|
||||
|
||||
protected:
|
||||
// Gets the size of space used by map field.
|
||||
virtual size_t SpaceUsedExcludingSelfNoLock() const;
|
||||
|
||||
// Synchronizes the content in Map to RepeatedPtrField if there is any change
|
||||
// to Map after last synchronization.
|
||||
void SyncRepeatedFieldWithMap() const;
|
||||
virtual void SyncRepeatedFieldWithMapNoLock() const;
|
||||
|
||||
// Synchronizes the content in RepeatedPtrField to Map if there is any change
|
||||
// to RepeatedPtrField after last synchronization.
|
||||
void SyncMapWithRepeatedField() const;
|
||||
virtual void SyncMapWithRepeatedFieldNoLock() const {}
|
||||
|
||||
// Tells MapFieldBase that there is new change to Map.
|
||||
void SetMapDirty();
|
||||
|
||||
// Tells MapFieldBase that there is new change to RepeatedPTrField.
|
||||
void SetRepeatedDirty();
|
||||
|
||||
// Provides derived class the access to repeated field.
|
||||
void* MutableRepeatedPtrField() const;
|
||||
|
||||
enum State {
|
||||
STATE_MODIFIED_MAP = 0, // map has newly added data that has not been
|
||||
// synchronized to repeated field
|
||||
STATE_MODIFIED_REPEATED = 1, // repeated field has newly added data that
|
||||
// has not been synchronized to map
|
||||
CLEAN = 2, // data in map and repeated field are same
|
||||
};
|
||||
|
||||
Arena* arena_;
|
||||
mutable RepeatedPtrField<Message>* repeated_field_;
|
||||
|
||||
mutable Mutex mutex_; // The thread to synchronize map and repeated field
|
||||
// needs to get lock first;
|
||||
mutable volatile Atomic32 state_; // 0: STATE_MODIFIED_MAP
|
||||
// 1: STATE_MODIFIED_REPEATED
|
||||
// 2: CLEAN
|
||||
|
||||
private:
|
||||
friend class ContendedMapCleanTest;
|
||||
friend class GeneratedMessageReflection;
|
||||
friend class MapFieldAccessor;
|
||||
friend class ::google::protobuf::DynamicMessage;
|
||||
|
||||
// Virtual helper methods for MapIterator. MapIterator doesn't have the
|
||||
// type helper for key and value. Call these help methods to deal with
|
||||
// different types. Real helper methods are implemented in
|
||||
// TypeDefinedMapFieldBase.
|
||||
friend class ::google::protobuf::MapIterator;
|
||||
// Allocate map<...>::iterator for MapIterator.
|
||||
virtual void InitializeIterator(MapIterator* map_iter) const = 0;
|
||||
|
||||
// DeleteIterator() is called by the destructor of MapIterator only.
|
||||
// It deletes map<...>::iterator for MapIterator.
|
||||
virtual void DeleteIterator(MapIterator* map_iter) const = 0;
|
||||
|
||||
// Copy the map<...>::iterator from other_iterator to
|
||||
// this_iterator.
|
||||
virtual void CopyIterator(MapIterator* this_iterator,
|
||||
const MapIterator& other_iterator) const = 0;
|
||||
|
||||
// IncreaseIterator() is called by operator++() of MapIterator only.
|
||||
// It implements the ++ operator of MapIterator.
|
||||
virtual void IncreaseIterator(MapIterator* map_iter) const = 0;
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldBase);
|
||||
};
|
||||
|
||||
// This class provides common Map Reflection implementations for generated
|
||||
// message and dynamic message.
|
||||
template<typename Key, typename T>
|
||||
class TypeDefinedMapFieldBase : public MapFieldBase {
|
||||
public:
|
||||
TypeDefinedMapFieldBase() {}
|
||||
explicit TypeDefinedMapFieldBase(Arena* arena) : MapFieldBase(arena) {}
|
||||
~TypeDefinedMapFieldBase() {}
|
||||
void MapBegin(MapIterator* map_iter) const;
|
||||
void MapEnd(MapIterator* map_iter) const;
|
||||
bool EqualIterator(const MapIterator& a, const MapIterator& b) const;
|
||||
|
||||
virtual const Map<Key, T>& GetMap() const = 0;
|
||||
virtual Map<Key, T>* MutableMap() = 0;
|
||||
|
||||
protected:
|
||||
typename Map<Key, T>::const_iterator& InternalGetIterator(
|
||||
const MapIterator* map_iter) const;
|
||||
|
||||
private:
|
||||
void InitializeIterator(MapIterator* map_iter) const;
|
||||
void DeleteIterator(MapIterator* map_iter) const;
|
||||
void CopyIterator(MapIterator* this_iteratorm,
|
||||
const MapIterator& that_iterator) const;
|
||||
void IncreaseIterator(MapIterator* map_iter) const;
|
||||
|
||||
virtual void SetMapIteratorValue(MapIterator* map_iter) const = 0;
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeDefinedMapFieldBase);
|
||||
};
|
||||
|
||||
// This class provides access to map field using generated api. It is used for
|
||||
// internal generated message implentation only. Users should never use this
|
||||
// directly.
|
||||
template <typename Derived, typename Key, typename T,
|
||||
WireFormatLite::FieldType kKeyFieldType,
|
||||
WireFormatLite::FieldType kValueFieldType, int default_enum_value = 0>
|
||||
class MapField : public TypeDefinedMapFieldBase<Key, T> {
|
||||
// Provide utilities to parse/serialize key/value. Provide utilities to
|
||||
// manipulate internal stored type.
|
||||
typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
|
||||
typedef MapTypeHandler<kValueFieldType, T> ValueTypeHandler;
|
||||
|
||||
// Define message type for internal repeated field.
|
||||
typedef Derived EntryType;
|
||||
typedef MapEntryLite<Derived, Key, T, kKeyFieldType, kValueFieldType,
|
||||
default_enum_value>
|
||||
EntryLiteType;
|
||||
|
||||
// Define abbreviation for parent MapFieldLite
|
||||
typedef MapFieldLite<Derived, Key, T, kKeyFieldType, kValueFieldType,
|
||||
default_enum_value>
|
||||
MapFieldLiteType;
|
||||
|
||||
// Enum needs to be handled differently from other types because it has
|
||||
// different exposed type in google::protobuf::Map's api and repeated field's api. For
|
||||
// details see the comment in the implementation of
|
||||
// SyncMapWithRepeatedFieldNoLock.
|
||||
static const bool kIsValueEnum = ValueTypeHandler::kIsEnum;
|
||||
typedef typename MapIf<kIsValueEnum, T, const T&>::type CastValueType;
|
||||
|
||||
public:
|
||||
typedef typename Derived::SuperType EntryTypeTrait;
|
||||
typedef Map<Key, T> MapType;
|
||||
|
||||
MapField() {}
|
||||
explicit MapField(Arena* arena)
|
||||
: TypeDefinedMapFieldBase<Key, T>(arena), impl_(arena) {}
|
||||
|
||||
// Implement MapFieldBase
|
||||
bool ContainsMapKey(const MapKey& map_key) const;
|
||||
bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val);
|
||||
bool DeleteMapValue(const MapKey& map_key);
|
||||
|
||||
const Map<Key, T>& GetMap() const {
|
||||
MapFieldBase::SyncMapWithRepeatedField();
|
||||
return impl_.GetMap();
|
||||
}
|
||||
|
||||
Map<Key, T>* MutableMap() {
|
||||
MapFieldBase::SyncMapWithRepeatedField();
|
||||
Map<Key, T>* result = impl_.MutableMap();
|
||||
MapFieldBase::SetMapDirty();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Convenient methods for generated message implementation.
|
||||
int size() const;
|
||||
void Clear();
|
||||
void MergeFrom(const MapField& other);
|
||||
void Swap(MapField* other);
|
||||
|
||||
// Used in the implementation of parsing. Caller should take the ownership iff
|
||||
// arena_ is NULL.
|
||||
EntryType* NewEntry() const { return impl_.NewEntry(); }
|
||||
// Used in the implementation of serializing enum value type. Caller should
|
||||
// take the ownership iff arena_ is NULL.
|
||||
EntryType* NewEnumEntryWrapper(const Key& key, const T t) const {
|
||||
return impl_.NewEnumEntryWrapper(key, t);
|
||||
}
|
||||
// Used in the implementation of serializing other value types. Caller should
|
||||
// take the ownership iff arena_ is NULL.
|
||||
EntryType* NewEntryWrapper(const Key& key, const T& t) const {
|
||||
return impl_.NewEntryWrapper(key, t);
|
||||
}
|
||||
|
||||
private:
|
||||
MapFieldLiteType impl_;
|
||||
|
||||
typedef void InternalArenaConstructable_;
|
||||
typedef void DestructorSkippable_;
|
||||
|
||||
// Implements MapFieldBase
|
||||
void SyncRepeatedFieldWithMapNoLock() const;
|
||||
void SyncMapWithRepeatedFieldNoLock() const;
|
||||
size_t SpaceUsedExcludingSelfNoLock() const;
|
||||
|
||||
void SetMapIteratorValue(MapIterator* map_iter) const;
|
||||
|
||||
friend class ::google::protobuf::Arena;
|
||||
friend class MapFieldStateTest; // For testing, it needs raw access to impl_
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapField);
|
||||
};
|
||||
|
||||
template <typename T, typename Key, typename Value,
|
||||
WireFormatLite::FieldType kKeyFieldType,
|
||||
WireFormatLite::FieldType kValueFieldType, int default_enum_value>
|
||||
struct MapEntryToMapField<MapEntry<T, Key, Value, kKeyFieldType,
|
||||
kValueFieldType, default_enum_value> > {
|
||||
typedef MapField<T, Key, Value, kKeyFieldType, kValueFieldType,
|
||||
default_enum_value>
|
||||
MapFieldType;
|
||||
};
|
||||
|
||||
class LIBPROTOBUF_EXPORT DynamicMapField: public TypeDefinedMapFieldBase<MapKey, MapValueRef> {
|
||||
public:
|
||||
explicit DynamicMapField(const Message* default_entry);
|
||||
DynamicMapField(const Message* default_entry, Arena* arena);
|
||||
~DynamicMapField();
|
||||
|
||||
// Implement MapFieldBase
|
||||
bool ContainsMapKey(const MapKey& map_key) const;
|
||||
bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val);
|
||||
bool DeleteMapValue(const MapKey& map_key);
|
||||
|
||||
const Map<MapKey, MapValueRef>& GetMap() const;
|
||||
Map<MapKey, MapValueRef>* MutableMap();
|
||||
|
||||
int size() const;
|
||||
|
||||
private:
|
||||
Map<MapKey, MapValueRef> map_;
|
||||
const Message* default_entry_;
|
||||
|
||||
// Implements MapFieldBase
|
||||
void SyncRepeatedFieldWithMapNoLock() const;
|
||||
void SyncMapWithRepeatedFieldNoLock() const;
|
||||
size_t SpaceUsedExcludingSelfNoLock() const;
|
||||
void SetMapIteratorValue(MapIterator* map_iter) const;
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMapField);
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
||||
#define TYPE_CHECK(EXPECTEDTYPE, METHOD) \
|
||||
if (type() != EXPECTEDTYPE) { \
|
||||
GOOGLE_LOG(FATAL) \
|
||||
<< "Protocol Buffer map usage error:\n" \
|
||||
<< METHOD << " type does not match\n" \
|
||||
<< " Expected : " \
|
||||
<< FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n" \
|
||||
<< " Actual : " \
|
||||
<< FieldDescriptor::CppTypeName(type()); \
|
||||
}
|
||||
|
||||
// MapKey is an union type for representing any possible
|
||||
// map key.
|
||||
class LIBPROTOBUF_EXPORT MapKey {
|
||||
public:
|
||||
MapKey() : type_(0) {
|
||||
}
|
||||
MapKey(const MapKey& other) : type_(0) {
|
||||
CopyFrom(other);
|
||||
}
|
||||
MapKey& operator=(const MapKey& other) {
|
||||
CopyFrom(other);
|
||||
return *this;
|
||||
}
|
||||
|
||||
~MapKey() {
|
||||
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
|
||||
delete val_.string_value_;
|
||||
}
|
||||
}
|
||||
|
||||
FieldDescriptor::CppType type() const {
|
||||
if (type_ == 0) {
|
||||
GOOGLE_LOG(FATAL)
|
||||
<< "Protocol Buffer map usage error:\n"
|
||||
<< "MapKey::type MapKey is not initialized. "
|
||||
<< "Call set methods to initialize MapKey.";
|
||||
}
|
||||
return (FieldDescriptor::CppType)type_;
|
||||
}
|
||||
|
||||
void SetInt64Value(int64 value) {
|
||||
SetType(FieldDescriptor::CPPTYPE_INT64);
|
||||
val_.int64_value_ = value;
|
||||
}
|
||||
void SetUInt64Value(uint64 value) {
|
||||
SetType(FieldDescriptor::CPPTYPE_UINT64);
|
||||
val_.uint64_value_ = value;
|
||||
}
|
||||
void SetInt32Value(int32 value) {
|
||||
SetType(FieldDescriptor::CPPTYPE_INT32);
|
||||
val_.int32_value_ = value;
|
||||
}
|
||||
void SetUInt32Value(uint32 value) {
|
||||
SetType(FieldDescriptor::CPPTYPE_UINT32);
|
||||
val_.uint32_value_ = value;
|
||||
}
|
||||
void SetBoolValue(bool value) {
|
||||
SetType(FieldDescriptor::CPPTYPE_BOOL);
|
||||
val_.bool_value_ = value;
|
||||
}
|
||||
void SetStringValue(const string& val) {
|
||||
SetType(FieldDescriptor::CPPTYPE_STRING);
|
||||
*val_.string_value_ = val;
|
||||
}
|
||||
|
||||
int64 GetInt64Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
|
||||
"MapKey::GetInt64Value");
|
||||
return val_.int64_value_;
|
||||
}
|
||||
uint64 GetUInt64Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
|
||||
"MapKey::GetUInt64Value");
|
||||
return val_.uint64_value_;
|
||||
}
|
||||
int32 GetInt32Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
|
||||
"MapKey::GetInt32Value");
|
||||
return val_.int32_value_;
|
||||
}
|
||||
uint32 GetUInt32Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
|
||||
"MapKey::GetUInt32Value");
|
||||
return val_.uint32_value_;
|
||||
}
|
||||
bool GetBoolValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
|
||||
"MapKey::GetBoolValue");
|
||||
return val_.bool_value_;
|
||||
}
|
||||
const string& GetStringValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
|
||||
"MapKey::GetStringValue");
|
||||
return *val_.string_value_;
|
||||
}
|
||||
|
||||
bool operator<(const MapKey& other) const {
|
||||
if (type_ != other.type_) {
|
||||
// We could define a total order that handles this case, but
|
||||
// there currently no need. So, for now, fail.
|
||||
GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
|
||||
}
|
||||
switch (type()) {
|
||||
case FieldDescriptor::CPPTYPE_DOUBLE:
|
||||
case FieldDescriptor::CPPTYPE_FLOAT:
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
GOOGLE_LOG(FATAL) << "Unsupported";
|
||||
return false;
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
return *val_.string_value_ < *other.val_.string_value_;
|
||||
case FieldDescriptor::CPPTYPE_INT64:
|
||||
return val_.int64_value_ < other.val_.int64_value_;
|
||||
case FieldDescriptor::CPPTYPE_INT32:
|
||||
return val_.int32_value_ < other.val_.int32_value_;
|
||||
case FieldDescriptor::CPPTYPE_UINT64:
|
||||
return val_.uint64_value_ < other.val_.uint64_value_;
|
||||
case FieldDescriptor::CPPTYPE_UINT32:
|
||||
return val_.uint32_value_ < other.val_.uint32_value_;
|
||||
case FieldDescriptor::CPPTYPE_BOOL:
|
||||
return val_.bool_value_ < other.val_.bool_value_;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool operator==(const MapKey& other) const {
|
||||
if (type_ != other.type_) {
|
||||
// To be consistent with operator<, we don't allow this either.
|
||||
GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
|
||||
}
|
||||
switch (type()) {
|
||||
case FieldDescriptor::CPPTYPE_DOUBLE:
|
||||
case FieldDescriptor::CPPTYPE_FLOAT:
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
GOOGLE_LOG(FATAL) << "Unsupported";
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
return *val_.string_value_ == *other.val_.string_value_;
|
||||
case FieldDescriptor::CPPTYPE_INT64:
|
||||
return val_.int64_value_ == other.val_.int64_value_;
|
||||
case FieldDescriptor::CPPTYPE_INT32:
|
||||
return val_.int32_value_ == other.val_.int32_value_;
|
||||
case FieldDescriptor::CPPTYPE_UINT64:
|
||||
return val_.uint64_value_ == other.val_.uint64_value_;
|
||||
case FieldDescriptor::CPPTYPE_UINT32:
|
||||
return val_.uint32_value_ == other.val_.uint32_value_;
|
||||
case FieldDescriptor::CPPTYPE_BOOL:
|
||||
return val_.bool_value_ == other.val_.bool_value_;
|
||||
}
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
return false;
|
||||
}
|
||||
|
||||
void CopyFrom(const MapKey& other) {
|
||||
SetType(other.type());
|
||||
switch (type_) {
|
||||
case FieldDescriptor::CPPTYPE_DOUBLE:
|
||||
case FieldDescriptor::CPPTYPE_FLOAT:
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
GOOGLE_LOG(FATAL) << "Unsupported";
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
*val_.string_value_ = *other.val_.string_value_;
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_INT64:
|
||||
val_.int64_value_ = other.val_.int64_value_;
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_INT32:
|
||||
val_.int32_value_ = other.val_.int32_value_;
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_UINT64:
|
||||
val_.uint64_value_ = other.val_.uint64_value_;
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_UINT32:
|
||||
val_.uint32_value_ = other.val_.uint32_value_;
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_BOOL:
|
||||
val_.bool_value_ = other.val_.bool_value_;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename K, typename V>
|
||||
friend class internal::TypeDefinedMapFieldBase;
|
||||
friend class MapIterator;
|
||||
friend class internal::DynamicMapField;
|
||||
|
||||
union KeyValue {
|
||||
KeyValue() {}
|
||||
string* string_value_;
|
||||
int64 int64_value_;
|
||||
int32 int32_value_;
|
||||
uint64 uint64_value_;
|
||||
uint32 uint32_value_;
|
||||
bool bool_value_;
|
||||
} val_;
|
||||
|
||||
void SetType(FieldDescriptor::CppType type) {
|
||||
if (type_ == type) return;
|
||||
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
|
||||
delete val_.string_value_;
|
||||
}
|
||||
type_ = type;
|
||||
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
|
||||
val_.string_value_ = new string;
|
||||
}
|
||||
}
|
||||
|
||||
// type_ is 0 or a valid FieldDescriptor::CppType.
|
||||
int type_;
|
||||
};
|
||||
|
||||
// MapValueRef points to a map value.
|
||||
class LIBPROTOBUF_EXPORT MapValueRef {
|
||||
public:
|
||||
MapValueRef() : data_(NULL), type_(0) {}
|
||||
|
||||
void SetInt64Value(int64 value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
|
||||
"MapValueRef::SetInt64Value");
|
||||
*reinterpret_cast<int64*>(data_) = value;
|
||||
}
|
||||
void SetUInt64Value(uint64 value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
|
||||
"MapValueRef::SetUInt64Value");
|
||||
*reinterpret_cast<uint64*>(data_) = value;
|
||||
}
|
||||
void SetInt32Value(int32 value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
|
||||
"MapValueRef::SetInt32Value");
|
||||
*reinterpret_cast<int32*>(data_) = value;
|
||||
}
|
||||
void SetUInt32Value(uint32 value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
|
||||
"MapValueRef::SetUInt32Value");
|
||||
*reinterpret_cast<uint32*>(data_) = value;
|
||||
}
|
||||
void SetBoolValue(bool value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
|
||||
"MapValueRef::SetBoolValue");
|
||||
*reinterpret_cast<bool*>(data_) = value;
|
||||
}
|
||||
// TODO(jieluo) - Checks that enum is member.
|
||||
void SetEnumValue(int value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM,
|
||||
"MapValueRef::SetEnumValue");
|
||||
*reinterpret_cast<int*>(data_) = value;
|
||||
}
|
||||
void SetStringValue(const string& value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
|
||||
"MapValueRef::SetStringValue");
|
||||
*reinterpret_cast<string*>(data_) = value;
|
||||
}
|
||||
void SetFloatValue(float value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
|
||||
"MapValueRef::SetFloatValue");
|
||||
*reinterpret_cast<float*>(data_) = value;
|
||||
}
|
||||
void SetDoubleValue(double value) {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
|
||||
"MapValueRef::SetDoubleValue");
|
||||
*reinterpret_cast<double*>(data_) = value;
|
||||
}
|
||||
|
||||
int64 GetInt64Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
|
||||
"MapValueRef::GetInt64Value");
|
||||
return *reinterpret_cast<int64*>(data_);
|
||||
}
|
||||
uint64 GetUInt64Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
|
||||
"MapValueRef::GetUInt64Value");
|
||||
return *reinterpret_cast<uint64*>(data_);
|
||||
}
|
||||
int32 GetInt32Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
|
||||
"MapValueRef::GetInt32Value");
|
||||
return *reinterpret_cast<int32*>(data_);
|
||||
}
|
||||
uint32 GetUInt32Value() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
|
||||
"MapValueRef::GetUInt32Value");
|
||||
return *reinterpret_cast<uint32*>(data_);
|
||||
}
|
||||
bool GetBoolValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
|
||||
"MapValueRef::GetBoolValue");
|
||||
return *reinterpret_cast<bool*>(data_);
|
||||
}
|
||||
int GetEnumValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM,
|
||||
"MapValueRef::GetEnumValue");
|
||||
return *reinterpret_cast<int*>(data_);
|
||||
}
|
||||
const string& GetStringValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
|
||||
"MapValueRef::GetStringValue");
|
||||
return *reinterpret_cast<string*>(data_);
|
||||
}
|
||||
float GetFloatValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
|
||||
"MapValueRef::GetFloatValue");
|
||||
return *reinterpret_cast<float*>(data_);
|
||||
}
|
||||
double GetDoubleValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
|
||||
"MapValueRef::GetDoubleValue");
|
||||
return *reinterpret_cast<double*>(data_);
|
||||
}
|
||||
|
||||
const Message& GetMessageValue() const {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
|
||||
"MapValueRef::GetMessageValue");
|
||||
return *reinterpret_cast<Message*>(data_);
|
||||
}
|
||||
|
||||
Message* MutableMessageValue() {
|
||||
TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
|
||||
"MapValueRef::MutableMessageValue");
|
||||
return reinterpret_cast<Message*>(data_);
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename Derived, typename K, typename V,
|
||||
internal::WireFormatLite::FieldType key_wire_type,
|
||||
internal::WireFormatLite::FieldType value_wire_type,
|
||||
int default_enum_value>
|
||||
friend class internal::MapField;
|
||||
template <typename K, typename V>
|
||||
friend class internal::TypeDefinedMapFieldBase;
|
||||
friend class MapIterator;
|
||||
friend class internal::GeneratedMessageReflection;
|
||||
friend class internal::DynamicMapField;
|
||||
|
||||
void SetType(FieldDescriptor::CppType type) {
|
||||
type_ = type;
|
||||
}
|
||||
|
||||
FieldDescriptor::CppType type() const {
|
||||
if (type_ == 0 || data_ == NULL) {
|
||||
GOOGLE_LOG(FATAL)
|
||||
<< "Protocol Buffer map usage error:\n"
|
||||
<< "MapValueRef::type MapValueRef is not initialized.";
|
||||
}
|
||||
return (FieldDescriptor::CppType)type_;
|
||||
}
|
||||
void SetValue(const void* val) {
|
||||
data_ = const_cast<void*>(val);
|
||||
}
|
||||
void CopyFrom(const MapValueRef& other) {
|
||||
type_ = other.type_;
|
||||
data_ = other.data_;
|
||||
}
|
||||
// Only used in DynamicMapField
|
||||
void DeleteData() {
|
||||
switch (type_) {
|
||||
#define HANDLE_TYPE(CPPTYPE, TYPE) \
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_##CPPTYPE: { \
|
||||
delete reinterpret_cast<TYPE*>(data_); \
|
||||
break; \
|
||||
}
|
||||
HANDLE_TYPE(INT32, int32);
|
||||
HANDLE_TYPE(INT64, int64);
|
||||
HANDLE_TYPE(UINT32, uint32);
|
||||
HANDLE_TYPE(UINT64, uint64);
|
||||
HANDLE_TYPE(DOUBLE, double);
|
||||
HANDLE_TYPE(FLOAT, float);
|
||||
HANDLE_TYPE(BOOL, bool);
|
||||
HANDLE_TYPE(STRING, string);
|
||||
HANDLE_TYPE(ENUM, int32);
|
||||
HANDLE_TYPE(MESSAGE, Message);
|
||||
#undef HANDLE_TYPE
|
||||
}
|
||||
}
|
||||
// data_ point to a map value. MapValueRef does not
|
||||
// own this value.
|
||||
void* data_;
|
||||
// type_ is 0 or a valid FieldDescriptor::CppType.
|
||||
int type_;
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapValueRef);
|
||||
};
|
||||
|
||||
#undef TYPE_CHECK
|
||||
|
||||
class LIBPROTOBUF_EXPORT MapIterator {
|
||||
public:
|
||||
MapIterator(Message* message, const FieldDescriptor* field) {
|
||||
const Reflection* reflection = message->GetReflection();
|
||||
map_ = reflection->MapData(message, field);
|
||||
key_.SetType(field->message_type()->FindFieldByName("key")->cpp_type());
|
||||
value_.SetType(field->message_type()->FindFieldByName("value")->cpp_type());
|
||||
map_->InitializeIterator(this);
|
||||
}
|
||||
MapIterator(const MapIterator& other) {
|
||||
map_ = other.map_;
|
||||
map_->InitializeIterator(this);
|
||||
map_->CopyIterator(this, other);
|
||||
}
|
||||
~MapIterator() {
|
||||
map_->DeleteIterator(this);
|
||||
}
|
||||
MapIterator& operator=(const MapIterator& other) {
|
||||
map_ = other.map_;
|
||||
map_->CopyIterator(this, other);
|
||||
return *this;
|
||||
}
|
||||
friend bool operator==(const MapIterator& a, const MapIterator& b) {
|
||||
return a.map_->EqualIterator(a, b);
|
||||
}
|
||||
friend bool operator!=(const MapIterator& a, const MapIterator& b) {
|
||||
return !a.map_->EqualIterator(a, b);
|
||||
}
|
||||
MapIterator& operator++() {
|
||||
map_->IncreaseIterator(this);
|
||||
return *this;
|
||||
}
|
||||
MapIterator operator++(int) {
|
||||
// iter_ is copied from Map<...>::iterator, no need to
|
||||
// copy from its self again. Use the same implementation
|
||||
// with operator++()
|
||||
map_->IncreaseIterator(this);
|
||||
return *this;
|
||||
}
|
||||
const MapKey& GetKey() {
|
||||
return key_;
|
||||
}
|
||||
const MapValueRef& GetValueRef() {
|
||||
return value_;
|
||||
}
|
||||
MapValueRef* MutableValueRef() {
|
||||
map_->SetMapDirty();
|
||||
return &value_;
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename Key, typename T>
|
||||
friend class internal::TypeDefinedMapFieldBase;
|
||||
friend class internal::DynamicMapField;
|
||||
template <typename Derived, typename Key, typename T,
|
||||
internal::WireFormatLite::FieldType kKeyFieldType,
|
||||
internal::WireFormatLite::FieldType kValueFieldType,
|
||||
int default_enum_value>
|
||||
friend class internal::MapField;
|
||||
|
||||
// reinterpret_cast from heap-allocated Map<...>::iterator*. MapIterator owns
|
||||
// the iterator. It is allocated by MapField<...>::InitializeIterator() called
|
||||
// in constructor and deleted by MapField<...>::DeleteIterator() called in
|
||||
// destructor.
|
||||
void* iter_;
|
||||
// Point to a MapField to call helper methods implemented in MapField.
|
||||
// MapIterator does not own this object.
|
||||
internal::MapFieldBase* map_;
|
||||
MapKey key_;
|
||||
MapValueRef value_;
|
||||
};
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START
|
||||
template<>
|
||||
struct hash<google::protobuf::MapKey> {
|
||||
size_t
|
||||
operator()(const google::protobuf::MapKey& map_key) const {
|
||||
switch (map_key.type()) {
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
GOOGLE_LOG(FATAL) << "Unsupported";
|
||||
break;
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
|
||||
return hash<string>()(map_key.GetStringValue());
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
|
||||
return hash< ::google::protobuf::int64>()(map_key.GetInt64Value());
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
|
||||
return hash< ::google::protobuf::int32>()(map_key.GetInt32Value());
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
|
||||
return hash< ::google::protobuf::uint64>()(map_key.GetUInt64Value());
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
|
||||
return hash< ::google::protobuf::uint32>()(map_key.GetUInt32Value());
|
||||
case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
|
||||
return hash<bool>()(map_key.GetBoolValue());
|
||||
}
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
return 0;
|
||||
}
|
||||
bool
|
||||
operator()(const google::protobuf::MapKey& map_key1,
|
||||
const google::protobuf::MapKey& map_key2) const {
|
||||
return map_key1 < map_key2;
|
||||
}
|
||||
};
|
||||
GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_MAP_FIELD_H__
|
||||
Reference in New Issue
Block a user