| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // http://code.google.com/p/protobuf/ |
| // |
| // 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. |
| |
| // Author: kenton@google.com (Kenton Varda) |
| // Based on original Protocol Buffers design by |
| // Sanjay Ghemawat, Jeff Dean, and others. |
| |
| #include <google/protobuf/stubs/hash.h> |
| #include <google/protobuf/stubs/common.h> |
| #include <google/protobuf/stubs/once.h> |
| #include <google/protobuf/extension_set.h> |
| #include <google/protobuf/message_lite.h> |
| #include <google/protobuf/io/coded_stream.h> |
| #include <google/protobuf/io/zero_copy_stream_impl.h> |
| #include <google/protobuf/wire_format_lite_inl.h> |
| #include <google/protobuf/repeated_field.h> |
| #include <google/protobuf/stubs/map-util.h> |
| |
| namespace google { |
| namespace protobuf { |
| namespace internal { |
| |
| namespace { |
| |
| inline WireFormatLite::FieldType real_type(FieldType type) { |
| GOOGLE_DCHECK(type > 0 && type <= WireFormatLite::MAX_FIELD_TYPE); |
| return static_cast<WireFormatLite::FieldType>(type); |
| } |
| |
| inline WireFormatLite::CppType cpp_type(FieldType type) { |
| return WireFormatLite::FieldTypeToCppType(real_type(type)); |
| } |
| |
| // Registry stuff. |
| typedef hash_map<pair<const MessageLite*, int>, |
| ExtensionInfo> ExtensionRegistry; |
| ExtensionRegistry* registry_ = NULL; |
| GOOGLE_PROTOBUF_DECLARE_ONCE(registry_init_); |
| |
| void DeleteRegistry() { |
| delete registry_; |
| registry_ = NULL; |
| } |
| |
| void InitRegistry() { |
| registry_ = new ExtensionRegistry; |
| internal::OnShutdown(&DeleteRegistry); |
| } |
| |
| // This function is only called at startup, so there is no need for thread- |
| // safety. |
| void Register(const MessageLite* containing_type, |
| int number, ExtensionInfo info) { |
| ::google::protobuf::GoogleOnceInit(®istry_init_, &InitRegistry); |
| |
| if (!InsertIfNotPresent(registry_, make_pair(containing_type, number), |
| info)) { |
| GOOGLE_LOG(FATAL) << "Multiple extension registrations for type \"" |
| << containing_type->GetTypeName() |
| << "\", field number " << number << "."; |
| } |
| } |
| |
| const ExtensionInfo* FindRegisteredExtension( |
| const MessageLite* containing_type, int number) { |
| return (registry_ == NULL) ? NULL : |
| FindOrNull(*registry_, make_pair(containing_type, number)); |
| } |
| |
| } // namespace |
| |
| ExtensionFinder::~ExtensionFinder() {} |
| |
| bool GeneratedExtensionFinder::Find(int number, ExtensionInfo* output) { |
| const ExtensionInfo* extension = |
| FindRegisteredExtension(containing_type_, number); |
| if (extension == NULL) { |
| return false; |
| } else { |
| *output = *extension; |
| return true; |
| } |
| } |
| |
| void ExtensionSet::RegisterExtension(const MessageLite* containing_type, |
| int number, FieldType type, |
| bool is_repeated, bool is_packed) { |
| GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_ENUM); |
| GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_MESSAGE); |
| GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_GROUP); |
| ExtensionInfo info(type, is_repeated, is_packed); |
| Register(containing_type, number, info); |
| } |
| |
| static bool CallNoArgValidityFunc(const void* arg, int number) { |
| // Note: Must use C-style cast here rather than reinterpret_cast because |
| // the C++ standard at one point did not allow casts between function and |
| // data pointers and some compilers enforce this for C++-style casts. No |
| // compiler enforces it for C-style casts since lots of C-style code has |
| // relied on these kinds of casts for a long time, despite being |
| // technically undefined. See: |
| // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#195 |
| // Also note: Some compilers do not allow function pointers to be "const". |
| // Which makes sense, I suppose, because it's meaningless. |
| return ((EnumValidityFunc*)arg)(number); |
| } |
| |
| void ExtensionSet::RegisterEnumExtension(const MessageLite* containing_type, |
| int number, FieldType type, |
| bool is_repeated, bool is_packed, |
| EnumValidityFunc* is_valid) { |
| GOOGLE_CHECK_EQ(type, WireFormatLite::TYPE_ENUM); |
| ExtensionInfo info(type, is_repeated, is_packed); |
| info.enum_validity_check.func = CallNoArgValidityFunc; |
| // See comment in CallNoArgValidityFunc() about why we use a c-style cast. |
| info.enum_validity_check.arg = (void*)is_valid; |
| Register(containing_type, number, info); |
| } |
| |
| void ExtensionSet::RegisterMessageExtension(const MessageLite* containing_type, |
| int number, FieldType type, |
| bool is_repeated, bool is_packed, |
| const MessageLite* prototype) { |
| GOOGLE_CHECK(type == WireFormatLite::TYPE_MESSAGE || |
| type == WireFormatLite::TYPE_GROUP); |
| ExtensionInfo info(type, is_repeated, is_packed); |
| info.message_prototype = prototype; |
| Register(containing_type, number, info); |
| } |
| |
| |
| // =================================================================== |
| // Constructors and basic methods. |
| |
| ExtensionSet::ExtensionSet() {} |
| |
| ExtensionSet::~ExtensionSet() { |
| for (map<int, Extension>::iterator iter = extensions_.begin(); |
| iter != extensions_.end(); ++iter) { |
| iter->second.Free(); |
| } |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // void ExtensionSet::AppendToList(const Descriptor* containing_type, |
| // const DescriptorPool* pool, |
| // vector<const FieldDescriptor*>* output) const |
| |
| bool ExtensionSet::Has(int number) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| if (iter == extensions_.end()) return false; |
| GOOGLE_DCHECK(!iter->second.is_repeated); |
| return !iter->second.is_cleared; |
| } |
| |
| int ExtensionSet::ExtensionSize(int number) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| if (iter == extensions_.end()) return false; |
| return iter->second.GetSize(); |
| } |
| |
| FieldType ExtensionSet::ExtensionType(int number) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| if (iter == extensions_.end()) { |
| GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (1). "; |
| return 0; |
| } |
| if (iter->second.is_cleared) { |
| GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (2). "; |
| } |
| return iter->second.type; |
| } |
| |
| void ExtensionSet::ClearExtension(int number) { |
| map<int, Extension>::iterator iter = extensions_.find(number); |
| if (iter == extensions_.end()) return; |
| iter->second.Clear(); |
| } |
| |
| // =================================================================== |
| // Field accessors |
| |
| namespace { |
| |
| enum Cardinality { |
| REPEATED, |
| OPTIONAL |
| }; |
| |
| } // namespace |
| |
| #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE) \ |
| GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? REPEATED : OPTIONAL, LABEL); \ |
| GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), WireFormatLite::CPPTYPE_##CPPTYPE) |
| |
| // ------------------------------------------------------------------- |
| // Primitives |
| |
| #define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE) \ |
| \ |
| LOWERCASE ExtensionSet::Get##CAMELCASE(int number, \ |
| LOWERCASE default_value) const { \ |
| map<int, Extension>::const_iterator iter = extensions_.find(number); \ |
| if (iter == extensions_.end() || iter->second.is_cleared) { \ |
| return default_value; \ |
| } else { \ |
| GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, UPPERCASE); \ |
| return iter->second.LOWERCASE##_value; \ |
| } \ |
| } \ |
| \ |
| void ExtensionSet::Set##CAMELCASE(int number, FieldType type, \ |
| LOWERCASE value, \ |
| const FieldDescriptor* descriptor) { \ |
| Extension* extension; \ |
| if (MaybeNewExtension(number, descriptor, &extension)) { \ |
| extension->type = type; \ |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \ |
| extension->is_repeated = false; \ |
| } else { \ |
| GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, UPPERCASE); \ |
| } \ |
| extension->is_cleared = false; \ |
| extension->LOWERCASE##_value = value; \ |
| } \ |
| \ |
| LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) const { \ |
| map<int, Extension>::const_iterator iter = extensions_.find(number); \ |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; \ |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE); \ |
| return iter->second.repeated_##LOWERCASE##_value->Get(index); \ |
| } \ |
| \ |
| void ExtensionSet::SetRepeated##CAMELCASE( \ |
| int number, int index, LOWERCASE value) { \ |
| map<int, Extension>::iterator iter = extensions_.find(number); \ |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; \ |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE); \ |
| iter->second.repeated_##LOWERCASE##_value->Set(index, value); \ |
| } \ |
| \ |
| void ExtensionSet::Add##CAMELCASE(int number, FieldType type, \ |
| bool packed, LOWERCASE value, \ |
| const FieldDescriptor* descriptor) { \ |
| Extension* extension; \ |
| if (MaybeNewExtension(number, descriptor, &extension)) { \ |
| extension->type = type; \ |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \ |
| extension->is_repeated = true; \ |
| extension->is_packed = packed; \ |
| extension->repeated_##LOWERCASE##_value = new RepeatedField<LOWERCASE>(); \ |
| } else { \ |
| GOOGLE_DCHECK_TYPE(*extension, REPEATED, UPPERCASE); \ |
| GOOGLE_DCHECK_EQ(extension->is_packed, packed); \ |
| } \ |
| extension->repeated_##LOWERCASE##_value->Add(value); \ |
| } |
| |
| PRIMITIVE_ACCESSORS( INT32, int32, Int32) |
| PRIMITIVE_ACCESSORS( INT64, int64, Int64) |
| PRIMITIVE_ACCESSORS(UINT32, uint32, UInt32) |
| PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64) |
| PRIMITIVE_ACCESSORS( FLOAT, float, Float) |
| PRIMITIVE_ACCESSORS(DOUBLE, double, Double) |
| PRIMITIVE_ACCESSORS( BOOL, bool, Bool) |
| |
| #undef PRIMITIVE_ACCESSORS |
| |
| // ------------------------------------------------------------------- |
| // Enums |
| |
| int ExtensionSet::GetEnum(int number, int default_value) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| if (iter == extensions_.end() || iter->second.is_cleared) { |
| // Not present. Return the default value. |
| return default_value; |
| } else { |
| GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, ENUM); |
| return iter->second.enum_value; |
| } |
| } |
| |
| void ExtensionSet::SetEnum(int number, FieldType type, int value, |
| const FieldDescriptor* descriptor) { |
| Extension* extension; |
| if (MaybeNewExtension(number, descriptor, &extension)) { |
| extension->type = type; |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM); |
| extension->is_repeated = false; |
| } else { |
| GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, ENUM); |
| } |
| extension->is_cleared = false; |
| extension->enum_value = value; |
| } |
| |
| int ExtensionSet::GetRepeatedEnum(int number, int index) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM); |
| return iter->second.repeated_enum_value->Get(index); |
| } |
| |
| void ExtensionSet::SetRepeatedEnum(int number, int index, int value) { |
| map<int, Extension>::iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM); |
| iter->second.repeated_enum_value->Set(index, value); |
| } |
| |
| void ExtensionSet::AddEnum(int number, FieldType type, |
| bool packed, int value, |
| const FieldDescriptor* descriptor) { |
| Extension* extension; |
| if (MaybeNewExtension(number, descriptor, &extension)) { |
| extension->type = type; |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM); |
| extension->is_repeated = true; |
| extension->is_packed = packed; |
| extension->repeated_enum_value = new RepeatedField<int>(); |
| } else { |
| GOOGLE_DCHECK_TYPE(*extension, REPEATED, ENUM); |
| GOOGLE_DCHECK_EQ(extension->is_packed, packed); |
| } |
| extension->repeated_enum_value->Add(value); |
| } |
| |
| // ------------------------------------------------------------------- |
| // Strings |
| |
| const string& ExtensionSet::GetString(int number, |
| const string& default_value) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| if (iter == extensions_.end() || iter->second.is_cleared) { |
| // Not present. Return the default value. |
| return default_value; |
| } else { |
| GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, STRING); |
| return *iter->second.string_value; |
| } |
| } |
| |
| string* ExtensionSet::MutableString(int number, FieldType type, |
| const FieldDescriptor* descriptor) { |
| Extension* extension; |
| if (MaybeNewExtension(number, descriptor, &extension)) { |
| extension->type = type; |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING); |
| extension->is_repeated = false; |
| extension->string_value = new string; |
| } else { |
| GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, STRING); |
| } |
| extension->is_cleared = false; |
| return extension->string_value; |
| } |
| |
| const string& ExtensionSet::GetRepeatedString(int number, int index) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING); |
| return iter->second.repeated_string_value->Get(index); |
| } |
| |
| string* ExtensionSet::MutableRepeatedString(int number, int index) { |
| map<int, Extension>::iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING); |
| return iter->second.repeated_string_value->Mutable(index); |
| } |
| |
| string* ExtensionSet::AddString(int number, FieldType type, |
| const FieldDescriptor* descriptor) { |
| Extension* extension; |
| if (MaybeNewExtension(number, descriptor, &extension)) { |
| extension->type = type; |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING); |
| extension->is_repeated = true; |
| extension->is_packed = false; |
| extension->repeated_string_value = new RepeatedPtrField<string>(); |
| } else { |
| GOOGLE_DCHECK_TYPE(*extension, REPEATED, STRING); |
| } |
| return extension->repeated_string_value->Add(); |
| } |
| |
| // ------------------------------------------------------------------- |
| // Messages |
| |
| const MessageLite& ExtensionSet::GetMessage( |
| int number, const MessageLite& default_value) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| if (iter == extensions_.end()) { |
| // Not present. Return the default value. |
| return default_value; |
| } else { |
| GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); |
| return *iter->second.message_value; |
| } |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // const MessageLite& ExtensionSet::GetMessage(int number, |
| // const Descriptor* message_type, |
| // MessageFactory* factory) const |
| |
| MessageLite* ExtensionSet::MutableMessage(int number, FieldType type, |
| const MessageLite& prototype, |
| const FieldDescriptor* descriptor) { |
| Extension* extension; |
| if (MaybeNewExtension(number, descriptor, &extension)) { |
| extension->type = type; |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE); |
| extension->is_repeated = false; |
| extension->message_value = prototype.New(); |
| } else { |
| GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, MESSAGE); |
| } |
| extension->is_cleared = false; |
| return extension->message_value; |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // MessageLite* ExtensionSet::MutableMessage(int number, FieldType type, |
| // const Descriptor* message_type, |
| // MessageFactory* factory) |
| |
| const MessageLite& ExtensionSet::GetRepeatedMessage( |
| int number, int index) const { |
| map<int, Extension>::const_iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE); |
| return iter->second.repeated_message_value->Get(index); |
| } |
| |
| MessageLite* ExtensionSet::MutableRepeatedMessage(int number, int index) { |
| map<int, Extension>::iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE); |
| return iter->second.repeated_message_value->Mutable(index); |
| } |
| |
| MessageLite* ExtensionSet::AddMessage(int number, FieldType type, |
| const MessageLite& prototype, |
| const FieldDescriptor* descriptor) { |
| Extension* extension; |
| if (MaybeNewExtension(number, descriptor, &extension)) { |
| extension->type = type; |
| GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE); |
| extension->is_repeated = true; |
| extension->repeated_message_value = |
| new RepeatedPtrField<MessageLite>(); |
| } else { |
| GOOGLE_DCHECK_TYPE(*extension, REPEATED, MESSAGE); |
| } |
| |
| // RepeatedPtrField<MessageLite> does not know how to Add() since it cannot |
| // allocate an abstract object, so we have to be tricky. |
| MessageLite* result = extension->repeated_message_value |
| ->AddFromCleared<internal::GenericTypeHandler<MessageLite> >(); |
| if (result == NULL) { |
| result = prototype.New(); |
| extension->repeated_message_value->AddAllocated(result); |
| } |
| return result; |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // MessageLite* ExtensionSet::AddMessage(int number, FieldType type, |
| // const Descriptor* message_type, |
| // MessageFactory* factory) |
| |
| #undef GOOGLE_DCHECK_TYPE |
| |
| void ExtensionSet::RemoveLast(int number) { |
| map<int, Extension>::iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| |
| Extension* extension = &iter->second; |
| GOOGLE_DCHECK(extension->is_repeated); |
| |
| switch(cpp_type(extension->type)) { |
| case WireFormatLite::CPPTYPE_INT32: |
| extension->repeated_int32_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_INT64: |
| extension->repeated_int64_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_UINT32: |
| extension->repeated_uint32_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_UINT64: |
| extension->repeated_uint64_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_FLOAT: |
| extension->repeated_float_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_DOUBLE: |
| extension->repeated_double_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_BOOL: |
| extension->repeated_bool_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_ENUM: |
| extension->repeated_enum_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_STRING: |
| extension->repeated_string_value->RemoveLast(); |
| break; |
| case WireFormatLite::CPPTYPE_MESSAGE: |
| extension->repeated_message_value->RemoveLast(); |
| break; |
| } |
| } |
| |
| void ExtensionSet::SwapElements(int number, int index1, int index2) { |
| map<int, Extension>::iterator iter = extensions_.find(number); |
| GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; |
| |
| Extension* extension = &iter->second; |
| GOOGLE_DCHECK(extension->is_repeated); |
| |
| switch(cpp_type(extension->type)) { |
| case WireFormatLite::CPPTYPE_INT32: |
| extension->repeated_int32_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_INT64: |
| extension->repeated_int64_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_UINT32: |
| extension->repeated_uint32_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_UINT64: |
| extension->repeated_uint64_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_FLOAT: |
| extension->repeated_float_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_DOUBLE: |
| extension->repeated_double_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_BOOL: |
| extension->repeated_bool_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_ENUM: |
| extension->repeated_enum_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_STRING: |
| extension->repeated_string_value->SwapElements(index1, index2); |
| break; |
| case WireFormatLite::CPPTYPE_MESSAGE: |
| extension->repeated_message_value->SwapElements(index1, index2); |
| break; |
| } |
| } |
| |
| // =================================================================== |
| |
| void ExtensionSet::Clear() { |
| for (map<int, Extension>::iterator iter = extensions_.begin(); |
| iter != extensions_.end(); ++iter) { |
| iter->second.Clear(); |
| } |
| } |
| |
| void ExtensionSet::MergeFrom(const ExtensionSet& other) { |
| for (map<int, Extension>::const_iterator iter = other.extensions_.begin(); |
| iter != other.extensions_.end(); ++iter) { |
| const Extension& other_extension = iter->second; |
| |
| if (other_extension.is_repeated) { |
| Extension* extension; |
| bool is_new = MaybeNewExtension(iter->first, other_extension.descriptor, |
| &extension); |
| if (is_new) { |
| // Extension did not already exist in set. |
| extension->type = other_extension.type; |
| extension->is_repeated = true; |
| } else { |
| GOOGLE_DCHECK_EQ(extension->type, other_extension.type); |
| GOOGLE_DCHECK(extension->is_repeated); |
| } |
| |
| switch (cpp_type(other_extension.type)) { |
| #define HANDLE_TYPE(UPPERCASE, LOWERCASE, REPEATED_TYPE) \ |
| case WireFormatLite::CPPTYPE_##UPPERCASE: \ |
| if (is_new) { \ |
| extension->repeated_##LOWERCASE##_value = \ |
| new REPEATED_TYPE; \ |
| } \ |
| extension->repeated_##LOWERCASE##_value->MergeFrom( \ |
| *other_extension.repeated_##LOWERCASE##_value); \ |
| break; |
| |
| HANDLE_TYPE( INT32, int32, RepeatedField < int32>); |
| HANDLE_TYPE( INT64, int64, RepeatedField < int64>); |
| HANDLE_TYPE( UINT32, uint32, RepeatedField < uint32>); |
| HANDLE_TYPE( UINT64, uint64, RepeatedField < uint64>); |
| HANDLE_TYPE( FLOAT, float, RepeatedField < float>); |
| HANDLE_TYPE( DOUBLE, double, RepeatedField < double>); |
| HANDLE_TYPE( BOOL, bool, RepeatedField < bool>); |
| HANDLE_TYPE( ENUM, enum, RepeatedField < int>); |
| HANDLE_TYPE( STRING, string, RepeatedPtrField< string>); |
| #undef HANDLE_TYPE |
| |
| case WireFormatLite::CPPTYPE_MESSAGE: |
| if (is_new) { |
| extension->repeated_message_value = |
| new RepeatedPtrField<MessageLite>(); |
| } |
| // We can't call RepeatedPtrField<MessageLite>::MergeFrom() because |
| // it would attempt to allocate new objects. |
| RepeatedPtrField<MessageLite>* other_repeated_message = |
| other_extension.repeated_message_value; |
| for (int i = 0; i < other_repeated_message->size(); i++) { |
| const MessageLite& other_message = other_repeated_message->Get(i); |
| MessageLite* target = extension->repeated_message_value |
| ->AddFromCleared<GenericTypeHandler<MessageLite> >(); |
| if (target == NULL) { |
| target = other_message.New(); |
| extension->repeated_message_value->AddAllocated(target); |
| } |
| target->CheckTypeAndMergeFrom(other_message); |
| } |
| break; |
| } |
| } else { |
| if (!other_extension.is_cleared) { |
| switch (cpp_type(other_extension.type)) { |
| #define HANDLE_TYPE(UPPERCASE, LOWERCASE, CAMELCASE) \ |
| case WireFormatLite::CPPTYPE_##UPPERCASE: \ |
| Set##CAMELCASE(iter->first, other_extension.type, \ |
| other_extension.LOWERCASE##_value, \ |
| other_extension.descriptor); \ |
| break; |
| |
| HANDLE_TYPE( INT32, int32, Int32); |
| HANDLE_TYPE( INT64, int64, Int64); |
| HANDLE_TYPE(UINT32, uint32, UInt32); |
| HANDLE_TYPE(UINT64, uint64, UInt64); |
| HANDLE_TYPE( FLOAT, float, Float); |
| HANDLE_TYPE(DOUBLE, double, Double); |
| HANDLE_TYPE( BOOL, bool, Bool); |
| HANDLE_TYPE( ENUM, enum, Enum); |
| #undef HANDLE_TYPE |
| case WireFormatLite::CPPTYPE_STRING: |
| SetString(iter->first, other_extension.type, |
| *other_extension.string_value, |
| other_extension.descriptor); |
| break; |
| case WireFormatLite::CPPTYPE_MESSAGE: |
| MutableMessage(iter->first, other_extension.type, |
| *other_extension.message_value, |
| other_extension.descriptor) |
| ->CheckTypeAndMergeFrom(*other_extension.message_value); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| void ExtensionSet::Swap(ExtensionSet* x) { |
| extensions_.swap(x->extensions_); |
| } |
| |
| bool ExtensionSet::IsInitialized() const { |
| // Extensions are never required. However, we need to check that all |
| // embedded messages are initialized. |
| for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
| iter != extensions_.end(); ++iter) { |
| const Extension& extension = iter->second; |
| if (cpp_type(extension.type) == WireFormatLite::CPPTYPE_MESSAGE) { |
| if (extension.is_repeated) { |
| for (int i = 0; i < extension.repeated_message_value->size(); i++) { |
| if (!extension.repeated_message_value->Get(i).IsInitialized()) { |
| return false; |
| } |
| } |
| } else { |
| if (!extension.is_cleared) { |
| if (!extension.message_value->IsInitialized()) return false; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input, |
| ExtensionFinder* extension_finder, |
| FieldSkipper* field_skipper) { |
| int number = WireFormatLite::GetTagFieldNumber(tag); |
| WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag); |
| |
| ExtensionInfo extension; |
| bool is_unknown; |
| if (!extension_finder->Find(number, &extension)) { |
| is_unknown = true; |
| } else if (extension.is_packed) { |
| is_unknown = (wire_type != WireFormatLite::WIRETYPE_LENGTH_DELIMITED); |
| } else { |
| WireFormatLite::WireType expected_wire_type = |
| WireFormatLite::WireTypeForFieldType(real_type(extension.type)); |
| is_unknown = (wire_type != expected_wire_type); |
| } |
| |
| if (is_unknown) { |
| field_skipper->SkipField(input, tag); |
| } else if (extension.is_packed) { |
| uint32 size; |
| if (!input->ReadVarint32(&size)) return false; |
| io::CodedInputStream::Limit limit = input->PushLimit(size); |
| |
| switch (extension.type) { |
| #define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| while (input->BytesUntilLimit() > 0) { \ |
| CPP_LOWERCASE value; \ |
| if (!WireFormatLite::ReadPrimitive< \ |
| CPP_LOWERCASE, WireFormatLite::TYPE_##UPPERCASE>( \ |
| input, &value)) return false; \ |
| Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \ |
| true, value, extension.descriptor); \ |
| } \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32); |
| HANDLE_TYPE( INT64, Int64, int64); |
| HANDLE_TYPE( UINT32, UInt32, uint32); |
| HANDLE_TYPE( UINT64, UInt64, uint64); |
| HANDLE_TYPE( SINT32, Int32, int32); |
| HANDLE_TYPE( SINT64, Int64, int64); |
| HANDLE_TYPE( FIXED32, UInt32, uint32); |
| HANDLE_TYPE( FIXED64, UInt64, uint64); |
| HANDLE_TYPE(SFIXED32, Int32, int32); |
| HANDLE_TYPE(SFIXED64, Int64, int64); |
| HANDLE_TYPE( FLOAT, Float, float); |
| HANDLE_TYPE( DOUBLE, Double, double); |
| HANDLE_TYPE( BOOL, Bool, bool); |
| #undef HANDLE_TYPE |
| |
| case WireFormatLite::TYPE_ENUM: |
| while (input->BytesUntilLimit() > 0) { |
| int value; |
| if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>( |
| input, &value)) return false; |
| if (extension.enum_validity_check.func( |
| extension.enum_validity_check.arg, value)) { |
| AddEnum(number, WireFormatLite::TYPE_ENUM, true, value, |
| extension.descriptor); |
| } |
| } |
| break; |
| |
| case WireFormatLite::TYPE_STRING: |
| case WireFormatLite::TYPE_BYTES: |
| case WireFormatLite::TYPE_GROUP: |
| case WireFormatLite::TYPE_MESSAGE: |
| GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed."; |
| break; |
| } |
| |
| input->PopLimit(limit); |
| } else { |
| switch (extension.type) { |
| #define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE, CPP_LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: { \ |
| CPP_LOWERCASE value; \ |
| if (!WireFormatLite::ReadPrimitive< \ |
| CPP_LOWERCASE, WireFormatLite::TYPE_##UPPERCASE>( \ |
| input, &value)) return false; \ |
| if (extension.is_repeated) { \ |
| Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, \ |
| false, value, extension.descriptor); \ |
| } else { \ |
| Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, \ |
| extension.descriptor); \ |
| } \ |
| } break |
| |
| HANDLE_TYPE( INT32, Int32, int32); |
| HANDLE_TYPE( INT64, Int64, int64); |
| HANDLE_TYPE( UINT32, UInt32, uint32); |
| HANDLE_TYPE( UINT64, UInt64, uint64); |
| HANDLE_TYPE( SINT32, Int32, int32); |
| HANDLE_TYPE( SINT64, Int64, int64); |
| HANDLE_TYPE( FIXED32, UInt32, uint32); |
| HANDLE_TYPE( FIXED64, UInt64, uint64); |
| HANDLE_TYPE(SFIXED32, Int32, int32); |
| HANDLE_TYPE(SFIXED64, Int64, int64); |
| HANDLE_TYPE( FLOAT, Float, float); |
| HANDLE_TYPE( DOUBLE, Double, double); |
| HANDLE_TYPE( BOOL, Bool, bool); |
| #undef HANDLE_TYPE |
| |
| case WireFormatLite::TYPE_ENUM: { |
| int value; |
| if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>( |
| input, &value)) return false; |
| |
| if (!extension.enum_validity_check.func( |
| extension.enum_validity_check.arg, value)) { |
| // Invalid value. Treat as unknown. |
| field_skipper->SkipUnknownEnum(number, value); |
| } else if (extension.is_repeated) { |
| AddEnum(number, WireFormatLite::TYPE_ENUM, false, value, |
| extension.descriptor); |
| } else { |
| SetEnum(number, WireFormatLite::TYPE_ENUM, value, |
| extension.descriptor); |
| } |
| break; |
| } |
| |
| case WireFormatLite::TYPE_STRING: { |
| string* value = extension.is_repeated ? |
| AddString(number, WireFormatLite::TYPE_STRING, extension.descriptor) : |
| MutableString(number, WireFormatLite::TYPE_STRING, |
| extension.descriptor); |
| if (!WireFormatLite::ReadString(input, value)) return false; |
| break; |
| } |
| |
| case WireFormatLite::TYPE_BYTES: { |
| string* value = extension.is_repeated ? |
| AddString(number, WireFormatLite::TYPE_STRING, extension.descriptor) : |
| MutableString(number, WireFormatLite::TYPE_STRING, |
| extension.descriptor); |
| if (!WireFormatLite::ReadBytes(input, value)) return false; |
| break; |
| } |
| |
| case WireFormatLite::TYPE_GROUP: { |
| MessageLite* value = extension.is_repeated ? |
| AddMessage(number, WireFormatLite::TYPE_GROUP, |
| *extension.message_prototype, extension.descriptor) : |
| MutableMessage(number, WireFormatLite::TYPE_GROUP, |
| *extension.message_prototype, extension.descriptor); |
| if (!WireFormatLite::ReadGroup(number, input, value)) return false; |
| break; |
| } |
| |
| case WireFormatLite::TYPE_MESSAGE: { |
| MessageLite* value = extension.is_repeated ? |
| AddMessage(number, WireFormatLite::TYPE_MESSAGE, |
| *extension.message_prototype, extension.descriptor) : |
| MutableMessage(number, WireFormatLite::TYPE_MESSAGE, |
| *extension.message_prototype, extension.descriptor); |
| if (!WireFormatLite::ReadMessage(input, value)) return false; |
| break; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input, |
| const MessageLite* containing_type, |
| UnknownFieldSet* unknown_fields) { |
| FieldSkipper skipper(unknown_fields); |
| GeneratedExtensionFinder finder(containing_type); |
| return ParseField(tag, input, &finder, &skipper); |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // bool ExtensionSet::ParseFieldHeavy(uint32 tag, io::CodedInputStream* input, |
| // const Message* containing_type, |
| // UnknownFieldSet* unknown_fields) |
| |
| bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input, |
| ExtensionFinder* extension_finder, |
| FieldSkipper* field_skipper) { |
| while (true) { |
| uint32 tag = input->ReadTag(); |
| switch (tag) { |
| case 0: |
| return true; |
| case WireFormatLite::kMessageSetItemStartTag: |
| if (!ParseMessageSetItem(input, extension_finder, field_skipper)) { |
| return false; |
| } |
| break; |
| default: |
| if (!ParseField(tag, input, extension_finder, field_skipper)) { |
| return false; |
| } |
| break; |
| } |
| } |
| } |
| |
| bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input, |
| const MessageLite* containing_type, |
| UnknownFieldSet* unknown_fields) { |
| FieldSkipper skipper(unknown_fields); |
| GeneratedExtensionFinder finder(containing_type); |
| return ParseMessageSet(input, &finder, &skipper); |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // bool ExtensionSet::ParseMessageSetHeavy(io::CodedInputStream* input, |
| // const Message* containing_type, |
| // UnknownFieldSet* unknown_fields); |
| |
| bool ExtensionSet::ParseMessageSetItem(io::CodedInputStream* input, |
| ExtensionFinder* extension_finder, |
| FieldSkipper* field_skipper) { |
| // TODO(kenton): It would be nice to share code between this and |
| // WireFormatLite::ParseAndMergeMessageSetItem(), but I think the |
| // differences would be hard to factor out. |
| |
| // This method parses a group which should contain two fields: |
| // required int32 type_id = 2; |
| // required data message = 3; |
| |
| // Once we see a type_id, we'll construct a fake tag for this extension |
| // which is the tag it would have had under the proto2 extensions wire |
| // format. |
| uint32 fake_tag = 0; |
| |
| // If we see message data before the type_id, we'll append it to this so |
| // we can parse it later. This will probably never happen in practice, |
| // as no MessageSet encoder I know of writes the message before the type ID. |
| // But, it's technically valid so we should allow it. |
| // TODO(kenton): Use a Cord instead? Do I care? |
| string message_data; |
| |
| while (true) { |
| uint32 tag = input->ReadTag(); |
| if (tag == 0) return false; |
| |
| switch (tag) { |
| case WireFormatLite::kMessageSetTypeIdTag: { |
| uint32 type_id; |
| if (!input->ReadVarint32(&type_id)) return false; |
| fake_tag = WireFormatLite::MakeTag(type_id, |
| WireFormatLite::WIRETYPE_LENGTH_DELIMITED); |
| |
| if (!message_data.empty()) { |
| // We saw some message data before the type_id. Have to parse it |
| // now. |
| io::CodedInputStream sub_input( |
| reinterpret_cast<const uint8*>(message_data.data()), |
| message_data.size()); |
| if (!ParseField(fake_tag, &sub_input, |
| extension_finder, field_skipper)) { |
| return false; |
| } |
| message_data.clear(); |
| } |
| |
| break; |
| } |
| |
| case WireFormatLite::kMessageSetMessageTag: { |
| if (fake_tag == 0) { |
| // We haven't seen a type_id yet. Append this data to message_data. |
| string temp; |
| uint32 length; |
| if (!input->ReadVarint32(&length)) return false; |
| if (!input->ReadString(&temp, length)) return false; |
| message_data.append(temp); |
| } else { |
| // Already saw type_id, so we can parse this directly. |
| if (!ParseField(fake_tag, input, |
| extension_finder, field_skipper)) { |
| return false; |
| } |
| } |
| |
| break; |
| } |
| |
| case WireFormatLite::kMessageSetItemEndTag: { |
| return true; |
| } |
| |
| default: { |
| if (!field_skipper->SkipField(input, tag)) return false; |
| } |
| } |
| } |
| } |
| |
| void ExtensionSet::SerializeWithCachedSizes( |
| int start_field_number, int end_field_number, |
| io::CodedOutputStream* output) const { |
| map<int, Extension>::const_iterator iter; |
| for (iter = extensions_.lower_bound(start_field_number); |
| iter != extensions_.end() && iter->first < end_field_number; |
| ++iter) { |
| iter->second.SerializeFieldWithCachedSizes(iter->first, output); |
| } |
| } |
| |
| void ExtensionSet::SerializeMessageSetWithCachedSizes( |
| io::CodedOutputStream* output) const { |
| map<int, Extension>::const_iterator iter; |
| for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) { |
| iter->second.SerializeMessageSetItemWithCachedSizes(iter->first, output); |
| } |
| } |
| |
| int ExtensionSet::ByteSize() const { |
| int total_size = 0; |
| |
| for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
| iter != extensions_.end(); ++iter) { |
| total_size += iter->second.ByteSize(iter->first); |
| } |
| |
| return total_size; |
| } |
| |
| int ExtensionSet::MessageSetByteSize() const { |
| int total_size = 0; |
| |
| for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
| iter != extensions_.end(); ++iter) { |
| total_size += iter->second.MessageSetItemByteSize(iter->first); |
| } |
| |
| return total_size; |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // int ExtensionSet::SpaceUsedExcludingSelf() const |
| |
| bool ExtensionSet::MaybeNewExtension(int number, |
| const FieldDescriptor* descriptor, |
| Extension** result) { |
| pair<map<int, Extension>::iterator, bool> insert_result = |
| extensions_.insert(make_pair(number, Extension())); |
| *result = &insert_result.first->second; |
| (*result)->descriptor = descriptor; |
| return insert_result.second; |
| } |
| |
| // =================================================================== |
| // Methods of ExtensionSet::Extension |
| |
| void ExtensionSet::Extension::Clear() { |
| if (is_repeated) { |
| switch (cpp_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ |
| case WireFormatLite::CPPTYPE_##UPPERCASE: \ |
| repeated_##LOWERCASE##_value->Clear(); \ |
| break |
| |
| HANDLE_TYPE( INT32, int32); |
| HANDLE_TYPE( INT64, int64); |
| HANDLE_TYPE( UINT32, uint32); |
| HANDLE_TYPE( UINT64, uint64); |
| HANDLE_TYPE( FLOAT, float); |
| HANDLE_TYPE( DOUBLE, double); |
| HANDLE_TYPE( BOOL, bool); |
| HANDLE_TYPE( ENUM, enum); |
| HANDLE_TYPE( STRING, string); |
| HANDLE_TYPE(MESSAGE, message); |
| #undef HANDLE_TYPE |
| } |
| } else { |
| if (!is_cleared) { |
| switch (cpp_type(type)) { |
| case WireFormatLite::CPPTYPE_STRING: |
| string_value->clear(); |
| break; |
| case WireFormatLite::CPPTYPE_MESSAGE: |
| message_value->Clear(); |
| break; |
| default: |
| // No need to do anything. Get*() will return the default value |
| // as long as is_cleared is true and Set*() will overwrite the |
| // previous value. |
| break; |
| } |
| |
| is_cleared = true; |
| } |
| } |
| } |
| |
| void ExtensionSet::Extension::SerializeFieldWithCachedSizes( |
| int number, |
| io::CodedOutputStream* output) const { |
| if (is_repeated) { |
| if (is_packed) { |
| if (cached_size == 0) return; |
| |
| WireFormatLite::WriteTag(number, |
| WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); |
| output->WriteVarint32(cached_size); |
| |
| switch (real_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ |
| WireFormatLite::Write##CAMELCASE##NoTag( \ |
| repeated_##LOWERCASE##_value->Get(i), output); \ |
| } \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32); |
| HANDLE_TYPE( INT64, Int64, int64); |
| HANDLE_TYPE( UINT32, UInt32, uint32); |
| HANDLE_TYPE( UINT64, UInt64, uint64); |
| HANDLE_TYPE( SINT32, SInt32, int32); |
| HANDLE_TYPE( SINT64, SInt64, int64); |
| HANDLE_TYPE( FIXED32, Fixed32, uint32); |
| HANDLE_TYPE( FIXED64, Fixed64, uint64); |
| HANDLE_TYPE(SFIXED32, SFixed32, int32); |
| HANDLE_TYPE(SFIXED64, SFixed64, int64); |
| HANDLE_TYPE( FLOAT, Float, float); |
| HANDLE_TYPE( DOUBLE, Double, double); |
| HANDLE_TYPE( BOOL, Bool, bool); |
| HANDLE_TYPE( ENUM, Enum, enum); |
| #undef HANDLE_TYPE |
| |
| case WireFormatLite::TYPE_STRING: |
| case WireFormatLite::TYPE_BYTES: |
| case WireFormatLite::TYPE_GROUP: |
| case WireFormatLite::TYPE_MESSAGE: |
| GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed."; |
| break; |
| } |
| } else { |
| switch (real_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ |
| WireFormatLite::Write##CAMELCASE(number, \ |
| repeated_##LOWERCASE##_value->Get(i), output); \ |
| } \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32); |
| HANDLE_TYPE( INT64, Int64, int64); |
| HANDLE_TYPE( UINT32, UInt32, uint32); |
| HANDLE_TYPE( UINT64, UInt64, uint64); |
| HANDLE_TYPE( SINT32, SInt32, int32); |
| HANDLE_TYPE( SINT64, SInt64, int64); |
| HANDLE_TYPE( FIXED32, Fixed32, uint32); |
| HANDLE_TYPE( FIXED64, Fixed64, uint64); |
| HANDLE_TYPE(SFIXED32, SFixed32, int32); |
| HANDLE_TYPE(SFIXED64, SFixed64, int64); |
| HANDLE_TYPE( FLOAT, Float, float); |
| HANDLE_TYPE( DOUBLE, Double, double); |
| HANDLE_TYPE( BOOL, Bool, bool); |
| HANDLE_TYPE( STRING, String, string); |
| HANDLE_TYPE( BYTES, Bytes, string); |
| HANDLE_TYPE( ENUM, Enum, enum); |
| HANDLE_TYPE( GROUP, Group, message); |
| HANDLE_TYPE( MESSAGE, Message, message); |
| #undef HANDLE_TYPE |
| } |
| } |
| } else if (!is_cleared) { |
| switch (real_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| WireFormatLite::Write##CAMELCASE(number, VALUE, output); \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32_value); |
| HANDLE_TYPE( INT64, Int64, int64_value); |
| HANDLE_TYPE( UINT32, UInt32, uint32_value); |
| HANDLE_TYPE( UINT64, UInt64, uint64_value); |
| HANDLE_TYPE( SINT32, SInt32, int32_value); |
| HANDLE_TYPE( SINT64, SInt64, int64_value); |
| HANDLE_TYPE( FIXED32, Fixed32, uint32_value); |
| HANDLE_TYPE( FIXED64, Fixed64, uint64_value); |
| HANDLE_TYPE(SFIXED32, SFixed32, int32_value); |
| HANDLE_TYPE(SFIXED64, SFixed64, int64_value); |
| HANDLE_TYPE( FLOAT, Float, float_value); |
| HANDLE_TYPE( DOUBLE, Double, double_value); |
| HANDLE_TYPE( BOOL, Bool, bool_value); |
| HANDLE_TYPE( STRING, String, *string_value); |
| HANDLE_TYPE( BYTES, Bytes, *string_value); |
| HANDLE_TYPE( ENUM, Enum, enum_value); |
| HANDLE_TYPE( GROUP, Group, *message_value); |
| HANDLE_TYPE( MESSAGE, Message, *message_value); |
| #undef HANDLE_TYPE |
| } |
| } |
| } |
| |
| void ExtensionSet::Extension::SerializeMessageSetItemWithCachedSizes( |
| int number, |
| io::CodedOutputStream* output) const { |
| if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) { |
| // Not a valid MessageSet extension, but serialize it the normal way. |
| SerializeFieldWithCachedSizes(number, output); |
| return; |
| } |
| |
| if (is_cleared) return; |
| |
| // Start group. |
| output->WriteTag(WireFormatLite::kMessageSetItemStartTag); |
| |
| // Write type ID. |
| WireFormatLite::WriteUInt32(WireFormatLite::kMessageSetTypeIdNumber, |
| number, |
| output); |
| // Write message. |
| WireFormatLite::WriteMessageMaybeToArray( |
| WireFormatLite::kMessageSetMessageNumber, |
| *message_value, |
| output); |
| |
| // End group. |
| output->WriteTag(WireFormatLite::kMessageSetItemEndTag); |
| } |
| |
| int ExtensionSet::Extension::ByteSize(int number) const { |
| int result = 0; |
| |
| if (is_repeated) { |
| if (is_packed) { |
| switch (real_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ |
| result += WireFormatLite::CAMELCASE##Size( \ |
| repeated_##LOWERCASE##_value->Get(i)); \ |
| } \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32); |
| HANDLE_TYPE( INT64, Int64, int64); |
| HANDLE_TYPE( UINT32, UInt32, uint32); |
| HANDLE_TYPE( UINT64, UInt64, uint64); |
| HANDLE_TYPE( SINT32, SInt32, int32); |
| HANDLE_TYPE( SINT64, SInt64, int64); |
| HANDLE_TYPE( ENUM, Enum, enum); |
| #undef HANDLE_TYPE |
| |
| // Stuff with fixed size. |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| result += WireFormatLite::k##CAMELCASE##Size * \ |
| repeated_##LOWERCASE##_value->size(); \ |
| break |
| HANDLE_TYPE( FIXED32, Fixed32, uint32); |
| HANDLE_TYPE( FIXED64, Fixed64, uint64); |
| HANDLE_TYPE(SFIXED32, SFixed32, int32); |
| HANDLE_TYPE(SFIXED64, SFixed64, int64); |
| HANDLE_TYPE( FLOAT, Float, float); |
| HANDLE_TYPE( DOUBLE, Double, double); |
| HANDLE_TYPE( BOOL, Bool, bool); |
| #undef HANDLE_TYPE |
| |
| case WireFormatLite::TYPE_STRING: |
| case WireFormatLite::TYPE_BYTES: |
| case WireFormatLite::TYPE_GROUP: |
| case WireFormatLite::TYPE_MESSAGE: |
| GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed."; |
| break; |
| } |
| |
| cached_size = result; |
| if (result > 0) { |
| result += io::CodedOutputStream::VarintSize32(result); |
| result += io::CodedOutputStream::VarintSize32( |
| WireFormatLite::MakeTag(number, |
| WireFormatLite::WIRETYPE_LENGTH_DELIMITED)); |
| } |
| } else { |
| int tag_size = WireFormatLite::TagSize(number, real_type(type)); |
| |
| switch (real_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| result += tag_size * repeated_##LOWERCASE##_value->size(); \ |
| for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ |
| result += WireFormatLite::CAMELCASE##Size( \ |
| repeated_##LOWERCASE##_value->Get(i)); \ |
| } \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32); |
| HANDLE_TYPE( INT64, Int64, int64); |
| HANDLE_TYPE( UINT32, UInt32, uint32); |
| HANDLE_TYPE( UINT64, UInt64, uint64); |
| HANDLE_TYPE( SINT32, SInt32, int32); |
| HANDLE_TYPE( SINT64, SInt64, int64); |
| HANDLE_TYPE( STRING, String, string); |
| HANDLE_TYPE( BYTES, Bytes, string); |
| HANDLE_TYPE( ENUM, Enum, enum); |
| HANDLE_TYPE( GROUP, Group, message); |
| HANDLE_TYPE( MESSAGE, Message, message); |
| #undef HANDLE_TYPE |
| |
| // Stuff with fixed size. |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| result += (tag_size + WireFormatLite::k##CAMELCASE##Size) * \ |
| repeated_##LOWERCASE##_value->size(); \ |
| break |
| HANDLE_TYPE( FIXED32, Fixed32, uint32); |
| HANDLE_TYPE( FIXED64, Fixed64, uint64); |
| HANDLE_TYPE(SFIXED32, SFixed32, int32); |
| HANDLE_TYPE(SFIXED64, SFixed64, int64); |
| HANDLE_TYPE( FLOAT, Float, float); |
| HANDLE_TYPE( DOUBLE, Double, double); |
| HANDLE_TYPE( BOOL, Bool, bool); |
| #undef HANDLE_TYPE |
| } |
| } |
| } else if (!is_cleared) { |
| result += WireFormatLite::TagSize(number, real_type(type)); |
| switch (real_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| result += WireFormatLite::CAMELCASE##Size(LOWERCASE); \ |
| break |
| |
| HANDLE_TYPE( INT32, Int32, int32_value); |
| HANDLE_TYPE( INT64, Int64, int64_value); |
| HANDLE_TYPE( UINT32, UInt32, uint32_value); |
| HANDLE_TYPE( UINT64, UInt64, uint64_value); |
| HANDLE_TYPE( SINT32, SInt32, int32_value); |
| HANDLE_TYPE( SINT64, SInt64, int64_value); |
| HANDLE_TYPE( STRING, String, *string_value); |
| HANDLE_TYPE( BYTES, Bytes, *string_value); |
| HANDLE_TYPE( ENUM, Enum, enum_value); |
| HANDLE_TYPE( GROUP, Group, *message_value); |
| HANDLE_TYPE( MESSAGE, Message, *message_value); |
| #undef HANDLE_TYPE |
| |
| // Stuff with fixed size. |
| #define HANDLE_TYPE(UPPERCASE, CAMELCASE) \ |
| case WireFormatLite::TYPE_##UPPERCASE: \ |
| result += WireFormatLite::k##CAMELCASE##Size; \ |
| break |
| HANDLE_TYPE( FIXED32, Fixed32); |
| HANDLE_TYPE( FIXED64, Fixed64); |
| HANDLE_TYPE(SFIXED32, SFixed32); |
| HANDLE_TYPE(SFIXED64, SFixed64); |
| HANDLE_TYPE( FLOAT, Float); |
| HANDLE_TYPE( DOUBLE, Double); |
| HANDLE_TYPE( BOOL, Bool); |
| #undef HANDLE_TYPE |
| } |
| } |
| |
| return result; |
| } |
| |
| int ExtensionSet::Extension::MessageSetItemByteSize(int number) const { |
| if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) { |
| // Not a valid MessageSet extension, but compute the byte size for it the |
| // normal way. |
| return ByteSize(number); |
| } |
| |
| if (is_cleared) return 0; |
| |
| int our_size = WireFormatLite::kMessageSetItemTagsSize; |
| |
| // type_id |
| our_size += io::CodedOutputStream::VarintSize32(number); |
| |
| // message |
| int message_size = message_value->ByteSize(); |
| |
| our_size += io::CodedOutputStream::VarintSize32(message_size); |
| our_size += message_size; |
| |
| return our_size; |
| } |
| |
| int ExtensionSet::Extension::GetSize() const { |
| GOOGLE_DCHECK(is_repeated); |
| switch (cpp_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ |
| case WireFormatLite::CPPTYPE_##UPPERCASE: \ |
| return repeated_##LOWERCASE##_value->size() |
| |
| HANDLE_TYPE( INT32, int32); |
| HANDLE_TYPE( INT64, int64); |
| HANDLE_TYPE( UINT32, uint32); |
| HANDLE_TYPE( UINT64, uint64); |
| HANDLE_TYPE( FLOAT, float); |
| HANDLE_TYPE( DOUBLE, double); |
| HANDLE_TYPE( BOOL, bool); |
| HANDLE_TYPE( ENUM, enum); |
| HANDLE_TYPE( STRING, string); |
| HANDLE_TYPE(MESSAGE, message); |
| #undef HANDLE_TYPE |
| } |
| |
| GOOGLE_LOG(FATAL) << "Can't get here."; |
| return 0; |
| } |
| |
| void ExtensionSet::Extension::Free() { |
| if (is_repeated) { |
| switch (cpp_type(type)) { |
| #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ |
| case WireFormatLite::CPPTYPE_##UPPERCASE: \ |
| delete repeated_##LOWERCASE##_value; \ |
| break |
| |
| HANDLE_TYPE( INT32, int32); |
| HANDLE_TYPE( INT64, int64); |
| HANDLE_TYPE( UINT32, uint32); |
| HANDLE_TYPE( UINT64, uint64); |
| HANDLE_TYPE( FLOAT, float); |
| HANDLE_TYPE( DOUBLE, double); |
| HANDLE_TYPE( BOOL, bool); |
| HANDLE_TYPE( ENUM, enum); |
| HANDLE_TYPE( STRING, string); |
| HANDLE_TYPE(MESSAGE, message); |
| #undef HANDLE_TYPE |
| } |
| } else { |
| switch (cpp_type(type)) { |
| case WireFormatLite::CPPTYPE_STRING: |
| delete string_value; |
| break; |
| case WireFormatLite::CPPTYPE_MESSAGE: |
| delete message_value; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| // Defined in extension_set_heavy.cc. |
| // int ExtensionSet::Extension::SpaceUsedExcludingSelf() const |
| |
| } // namespace internal |
| } // namespace protobuf |
| } // namespace google |
