| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: mobile_operator_db.proto |
| |
| #include "mobile_operator_db.pb.h" |
| |
| #include <algorithm> |
| #include "google/protobuf/io/coded_stream.h" |
| #include "google/protobuf/extension_set.h" |
| #include "google/protobuf/wire_format_lite.h" |
| #include "google/protobuf/io/zero_copy_stream_impl_lite.h" |
| // @@protoc_insertion_point(includes) |
| |
| // Must be included last. |
| #include "google/protobuf/port_def.inc" |
| PROTOBUF_PRAGMA_INIT_SEG |
| namespace _pb = ::PROTOBUF_NAMESPACE_ID; |
| namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; |
| namespace shill { |
| namespace mobile_operator_db { |
| template <typename> |
| PROTOBUF_CONSTEXPR FilterRange::FilterRange( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.start_)*/ ::uint64_t{0u} |
| |
| , /*decltype(_impl_.end_)*/ ::uint64_t{0u} |
| } {} |
| struct FilterRangeDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR FilterRangeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~FilterRangeDefaultTypeInternal() {} |
| union { |
| FilterRange _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FilterRangeDefaultTypeInternal _FilterRange_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR Filter::Filter( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.range_)*/{} |
| , /*decltype(_impl_.regex_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.exclude_regex_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.type_)*/ 1 |
| } {} |
| struct FilterDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR FilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~FilterDefaultTypeInternal() {} |
| union { |
| Filter _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FilterDefaultTypeInternal _Filter_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR LocalizedName::LocalizedName( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.name_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.language_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| } {} |
| struct LocalizedNameDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR LocalizedNameDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~LocalizedNameDefaultTypeInternal() {} |
| union { |
| LocalizedName _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR MobileAPN::MobileAPN( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.localized_name_)*/{} |
| , /*decltype(_impl_.obsolete_dns_)*/{} |
| , /*decltype(_impl_.apn_filter_)*/{} |
| , /*decltype(_impl_.type_)*/ {} |
| |
| , /*decltype(_impl_.apn_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.obsolete_gateway_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.username_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.password_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.authentication_)*/ 0 |
| |
| , /*decltype(_impl_.obsolete_is_attach_apn_)*/ false |
| |
| , /*decltype(_impl_.is_required_by_carrier_spec_)*/ false |
| |
| , /*decltype(_impl_.ip_type_)*/ 1 |
| } {} |
| struct MobileAPNDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR MobileAPNDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~MobileAPNDefaultTypeInternal() {} |
| union { |
| MobileAPN _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MobileAPNDefaultTypeInternal _MobileAPN_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR OnlinePortal::OnlinePortal( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.url_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.post_data_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.olp_filter_)*/nullptr |
| , /*decltype(_impl_.method_)*/ 1 |
| } {} |
| struct OnlinePortalDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR OnlinePortalDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~OnlinePortalDefaultTypeInternal() {} |
| union { |
| OnlinePortal _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OnlinePortalDefaultTypeInternal _OnlinePortal_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR Data::Data( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.localized_name_)*/{} |
| , /*decltype(_impl_.olp_)*/{} |
| , /*decltype(_impl_.roaming_filter_)*/{} |
| , /*decltype(_impl_.mhs_entitlement_param_)*/ {} |
| |
| , /*decltype(_impl_.mccmnc_)*/{} |
| , /*decltype(_impl_.mobile_apn_)*/{} |
| , /*decltype(_impl_.uuid_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.country_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.mhs_entitlement_url_)*/ { |
| &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} |
| } |
| |
| , /*decltype(_impl_.mtu_)*/ 0 |
| |
| , /*decltype(_impl_.requires_roaming_)*/ false |
| |
| , /*decltype(_impl_.prioritizes_name_)*/ false |
| |
| , /*decltype(_impl_.tethering_allowed_)*/ false |
| |
| , /*decltype(_impl_.use_dun_apn_as_default_)*/ false |
| |
| , /*decltype(_impl_.mhs_entitlement_method_)*/ 2 |
| } {} |
| struct DataDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR DataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~DataDefaultTypeInternal() {} |
| union { |
| Data _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DataDefaultTypeInternal _Data_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR MobileVirtualNetworkOperator::MobileVirtualNetworkOperator( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.mvno_filter_)*/{} |
| , /*decltype(_impl_.data_)*/nullptr} {} |
| struct MobileVirtualNetworkOperatorDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR MobileVirtualNetworkOperatorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~MobileVirtualNetworkOperatorDefaultTypeInternal() {} |
| union { |
| MobileVirtualNetworkOperator _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MobileVirtualNetworkOperatorDefaultTypeInternal _MobileVirtualNetworkOperator_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR MobileNetworkOperator::MobileNetworkOperator( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_._has_bits_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , /*decltype(_impl_.mvno_)*/{} |
| , /*decltype(_impl_.data_)*/nullptr |
| , /*decltype(_impl_.earmarked_)*/ false |
| } {} |
| struct MobileNetworkOperatorDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR MobileNetworkOperatorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~MobileNetworkOperatorDefaultTypeInternal() {} |
| union { |
| MobileNetworkOperator _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MobileNetworkOperatorDefaultTypeInternal _MobileNetworkOperator_default_instance_; |
| template <typename> |
| PROTOBUF_CONSTEXPR MobileOperatorDB::MobileOperatorDB( |
| ::_pbi::ConstantInitialized): _impl_{ |
| /*decltype(_impl_.mno_)*/{} |
| , /*decltype(_impl_.mvno_)*/{} |
| , /*decltype(_impl_._cached_size_)*/{}} {} |
| struct MobileOperatorDBDefaultTypeInternal { |
| PROTOBUF_CONSTEXPR MobileOperatorDBDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} |
| ~MobileOperatorDBDefaultTypeInternal() {} |
| union { |
| MobileOperatorDB _instance; |
| }; |
| }; |
| |
| PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT |
| PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MobileOperatorDBDefaultTypeInternal _MobileOperatorDB_default_instance_; |
| } // namespace mobile_operator_db |
| } // namespace shill |
| namespace shill { |
| namespace mobile_operator_db { |
| bool Filter_Type_IsValid(int value) { |
| switch (value) { |
| case 1: |
| case 2: |
| case 3: |
| case 4: |
| case 5: |
| case 6: |
| return true; |
| default: |
| return false; |
| } |
| } |
| static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> |
| Filter_Type_strings[6] = {}; |
| |
| static const char Filter_Type_names[] = { |
| "GID1" |
| "ICCID" |
| "IMSI" |
| "MCCMNC" |
| "OBSOLETE_SID" |
| "OPERATOR_NAME" |
| }; |
| |
| static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Filter_Type_entries[] = |
| { |
| {{&Filter_Type_names[0], 4}, 6}, |
| {{&Filter_Type_names[4], 5}, 2}, |
| {{&Filter_Type_names[9], 4}, 1}, |
| {{&Filter_Type_names[13], 6}, 5}, |
| {{&Filter_Type_names[19], 12}, 3}, |
| {{&Filter_Type_names[31], 13}, 4}, |
| }; |
| |
| static const int Filter_Type_entries_by_number[] = { |
| 2, // 1 -> IMSI |
| 1, // 2 -> ICCID |
| 4, // 3 -> OBSOLETE_SID |
| 5, // 4 -> OPERATOR_NAME |
| 3, // 5 -> MCCMNC |
| 0, // 6 -> GID1 |
| }; |
| |
| const std::string& Filter_Type_Name(Filter_Type value) { |
| static const bool kDummy = |
| ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( |
| Filter_Type_entries, Filter_Type_entries_by_number, |
| 6, Filter_Type_strings); |
| (void)kDummy; |
| |
| int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( |
| Filter_Type_entries, Filter_Type_entries_by_number, 6, |
| value); |
| return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() |
| : Filter_Type_strings[idx].get(); |
| } |
| |
| bool Filter_Type_Parse(absl::string_view name, Filter_Type* value) { |
| int int_value; |
| bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( |
| Filter_Type_entries, 6, name, &int_value); |
| if (success) { |
| *value = static_cast<Filter_Type>(int_value); |
| } |
| return success; |
| } |
| #if (__cplusplus < 201703) && \ |
| (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| |
| constexpr Filter_Type Filter::IMSI; |
| constexpr Filter_Type Filter::ICCID; |
| constexpr Filter_Type Filter::OBSOLETE_SID; |
| constexpr Filter_Type Filter::OPERATOR_NAME; |
| constexpr Filter_Type Filter::MCCMNC; |
| constexpr Filter_Type Filter::GID1; |
| constexpr Filter_Type Filter::Type_MIN; |
| constexpr Filter_Type Filter::Type_MAX; |
| constexpr int Filter::Type_ARRAYSIZE; |
| |
| #endif // (__cplusplus < 201703) && |
| // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| bool MobileAPN_Authentication_IsValid(int value) { |
| switch (value) { |
| case 0: |
| case 1: |
| case 2: |
| return true; |
| default: |
| return false; |
| } |
| } |
| static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> |
| MobileAPN_Authentication_strings[3] = {}; |
| |
| static const char MobileAPN_Authentication_names[] = { |
| "CHAP" |
| "DEFAULT_AUTH" |
| "PAP" |
| }; |
| |
| static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MobileAPN_Authentication_entries[] = |
| { |
| {{&MobileAPN_Authentication_names[0], 4}, 2}, |
| {{&MobileAPN_Authentication_names[4], 12}, 0}, |
| {{&MobileAPN_Authentication_names[16], 3}, 1}, |
| }; |
| |
| static const int MobileAPN_Authentication_entries_by_number[] = { |
| 1, // 0 -> DEFAULT_AUTH |
| 2, // 1 -> PAP |
| 0, // 2 -> CHAP |
| }; |
| |
| const std::string& MobileAPN_Authentication_Name(MobileAPN_Authentication value) { |
| static const bool kDummy = |
| ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( |
| MobileAPN_Authentication_entries, MobileAPN_Authentication_entries_by_number, |
| 3, MobileAPN_Authentication_strings); |
| (void)kDummy; |
| |
| int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( |
| MobileAPN_Authentication_entries, MobileAPN_Authentication_entries_by_number, 3, |
| value); |
| return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() |
| : MobileAPN_Authentication_strings[idx].get(); |
| } |
| |
| bool MobileAPN_Authentication_Parse(absl::string_view name, MobileAPN_Authentication* value) { |
| int int_value; |
| bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( |
| MobileAPN_Authentication_entries, 3, name, &int_value); |
| if (success) { |
| *value = static_cast<MobileAPN_Authentication>(int_value); |
| } |
| return success; |
| } |
| #if (__cplusplus < 201703) && \ |
| (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| |
| constexpr MobileAPN_Authentication MobileAPN::DEFAULT_AUTH; |
| constexpr MobileAPN_Authentication MobileAPN::PAP; |
| constexpr MobileAPN_Authentication MobileAPN::CHAP; |
| constexpr MobileAPN_Authentication MobileAPN::Authentication_MIN; |
| constexpr MobileAPN_Authentication MobileAPN::Authentication_MAX; |
| constexpr int MobileAPN::Authentication_ARRAYSIZE; |
| |
| #endif // (__cplusplus < 201703) && |
| // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| bool MobileAPN_IpType_IsValid(int value) { |
| switch (value) { |
| case 0: |
| case 1: |
| case 2: |
| case 3: |
| return true; |
| default: |
| return false; |
| } |
| } |
| static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> |
| MobileAPN_IpType_strings[4] = {}; |
| |
| static const char MobileAPN_IpType_names[] = { |
| "IPV4" |
| "IPV4V6" |
| "IPV6" |
| "UNKNOWN" |
| }; |
| |
| static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MobileAPN_IpType_entries[] = |
| { |
| {{&MobileAPN_IpType_names[0], 4}, 1}, |
| {{&MobileAPN_IpType_names[4], 6}, 3}, |
| {{&MobileAPN_IpType_names[10], 4}, 2}, |
| {{&MobileAPN_IpType_names[14], 7}, 0}, |
| }; |
| |
| static const int MobileAPN_IpType_entries_by_number[] = { |
| 3, // 0 -> UNKNOWN |
| 0, // 1 -> IPV4 |
| 2, // 2 -> IPV6 |
| 1, // 3 -> IPV4V6 |
| }; |
| |
| const std::string& MobileAPN_IpType_Name(MobileAPN_IpType value) { |
| static const bool kDummy = |
| ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( |
| MobileAPN_IpType_entries, MobileAPN_IpType_entries_by_number, |
| 4, MobileAPN_IpType_strings); |
| (void)kDummy; |
| |
| int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( |
| MobileAPN_IpType_entries, MobileAPN_IpType_entries_by_number, 4, |
| value); |
| return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() |
| : MobileAPN_IpType_strings[idx].get(); |
| } |
| |
| bool MobileAPN_IpType_Parse(absl::string_view name, MobileAPN_IpType* value) { |
| int int_value; |
| bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( |
| MobileAPN_IpType_entries, 4, name, &int_value); |
| if (success) { |
| *value = static_cast<MobileAPN_IpType>(int_value); |
| } |
| return success; |
| } |
| #if (__cplusplus < 201703) && \ |
| (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| |
| constexpr MobileAPN_IpType MobileAPN::UNKNOWN; |
| constexpr MobileAPN_IpType MobileAPN::IPV4; |
| constexpr MobileAPN_IpType MobileAPN::IPV6; |
| constexpr MobileAPN_IpType MobileAPN::IPV4V6; |
| constexpr MobileAPN_IpType MobileAPN::IpType_MIN; |
| constexpr MobileAPN_IpType MobileAPN::IpType_MAX; |
| constexpr int MobileAPN::IpType_ARRAYSIZE; |
| |
| #endif // (__cplusplus < 201703) && |
| // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| bool MobileAPN_ApnType_IsValid(int value) { |
| switch (value) { |
| case 0: |
| case 1: |
| case 2: |
| return true; |
| default: |
| return false; |
| } |
| } |
| static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> |
| MobileAPN_ApnType_strings[3] = {}; |
| |
| static const char MobileAPN_ApnType_names[] = { |
| "DEFAULT" |
| "DUN" |
| "IA" |
| }; |
| |
| static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MobileAPN_ApnType_entries[] = |
| { |
| {{&MobileAPN_ApnType_names[0], 7}, 0}, |
| {{&MobileAPN_ApnType_names[7], 3}, 2}, |
| {{&MobileAPN_ApnType_names[10], 2}, 1}, |
| }; |
| |
| static const int MobileAPN_ApnType_entries_by_number[] = { |
| 0, // 0 -> DEFAULT |
| 2, // 1 -> IA |
| 1, // 2 -> DUN |
| }; |
| |
| const std::string& MobileAPN_ApnType_Name(MobileAPN_ApnType value) { |
| static const bool kDummy = |
| ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( |
| MobileAPN_ApnType_entries, MobileAPN_ApnType_entries_by_number, |
| 3, MobileAPN_ApnType_strings); |
| (void)kDummy; |
| |
| int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( |
| MobileAPN_ApnType_entries, MobileAPN_ApnType_entries_by_number, 3, |
| value); |
| return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() |
| : MobileAPN_ApnType_strings[idx].get(); |
| } |
| |
| bool MobileAPN_ApnType_Parse(absl::string_view name, MobileAPN_ApnType* value) { |
| int int_value; |
| bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( |
| MobileAPN_ApnType_entries, 3, name, &int_value); |
| if (success) { |
| *value = static_cast<MobileAPN_ApnType>(int_value); |
| } |
| return success; |
| } |
| #if (__cplusplus < 201703) && \ |
| (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| |
| constexpr MobileAPN_ApnType MobileAPN::DEFAULT; |
| constexpr MobileAPN_ApnType MobileAPN::IA; |
| constexpr MobileAPN_ApnType MobileAPN::DUN; |
| constexpr MobileAPN_ApnType MobileAPN::ApnType_MIN; |
| constexpr MobileAPN_ApnType MobileAPN::ApnType_MAX; |
| constexpr int MobileAPN::ApnType_ARRAYSIZE; |
| |
| #endif // (__cplusplus < 201703) && |
| // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| bool Data_EntitlementParam_IsValid(int value) { |
| switch (value) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> |
| Data_EntitlementParam_strings[1] = {}; |
| |
| static const char Data_EntitlementParam_names[] = { |
| "IMSI" |
| }; |
| |
| static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Data_EntitlementParam_entries[] = |
| { |
| {{&Data_EntitlementParam_names[0], 4}, 1}, |
| }; |
| |
| static const int Data_EntitlementParam_entries_by_number[] = { |
| 0, // 1 -> IMSI |
| }; |
| |
| const std::string& Data_EntitlementParam_Name(Data_EntitlementParam value) { |
| static const bool kDummy = |
| ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( |
| Data_EntitlementParam_entries, Data_EntitlementParam_entries_by_number, |
| 1, Data_EntitlementParam_strings); |
| (void)kDummy; |
| |
| int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( |
| Data_EntitlementParam_entries, Data_EntitlementParam_entries_by_number, 1, |
| value); |
| return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() |
| : Data_EntitlementParam_strings[idx].get(); |
| } |
| |
| bool Data_EntitlementParam_Parse(absl::string_view name, Data_EntitlementParam* value) { |
| int int_value; |
| bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( |
| Data_EntitlementParam_entries, 1, name, &int_value); |
| if (success) { |
| *value = static_cast<Data_EntitlementParam>(int_value); |
| } |
| return success; |
| } |
| #if (__cplusplus < 201703) && \ |
| (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| |
| constexpr Data_EntitlementParam Data::IMSI; |
| constexpr Data_EntitlementParam Data::EntitlementParam_MIN; |
| constexpr Data_EntitlementParam Data::EntitlementParam_MAX; |
| constexpr int Data::EntitlementParam_ARRAYSIZE; |
| |
| #endif // (__cplusplus < 201703) && |
| // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) |
| bool HttpMethod_IsValid(int value) { |
| switch (value) { |
| case 1: |
| case 2: |
| return true; |
| default: |
| return false; |
| } |
| } |
| static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> |
| HttpMethod_strings[2] = {}; |
| |
| static const char HttpMethod_names[] = { |
| "GET" |
| "POST" |
| }; |
| |
| static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry HttpMethod_entries[] = |
| { |
| {{&HttpMethod_names[0], 3}, 1}, |
| {{&HttpMethod_names[3], 4}, 2}, |
| }; |
| |
| static const int HttpMethod_entries_by_number[] = { |
| 0, // 1 -> GET |
| 1, // 2 -> POST |
| }; |
| |
| const std::string& HttpMethod_Name(HttpMethod value) { |
| static const bool kDummy = |
| ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( |
| HttpMethod_entries, HttpMethod_entries_by_number, |
| 2, HttpMethod_strings); |
| (void)kDummy; |
| |
| int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( |
| HttpMethod_entries, HttpMethod_entries_by_number, 2, |
| value); |
| return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() |
| : HttpMethod_strings[idx].get(); |
| } |
| |
| bool HttpMethod_Parse(absl::string_view name, HttpMethod* value) { |
| int int_value; |
| bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( |
| HttpMethod_entries, 2, name, &int_value); |
| if (success) { |
| *value = static_cast<HttpMethod>(int_value); |
| } |
| return success; |
| } |
| // =================================================================== |
| |
| class FilterRange::_Internal { |
| public: |
| using HasBits = decltype(std::declval<FilterRange>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(FilterRange, _impl_._has_bits_); |
| static void set_has_start(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_end(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0; |
| } |
| }; |
| |
| FilterRange::FilterRange(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.FilterRange) |
| } |
| FilterRange::FilterRange(const FilterRange& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) { |
| _internal_metadata_.MergeFrom<std::string>( |
| from._internal_metadata_); |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.FilterRange) |
| } |
| |
| inline void FilterRange::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.start_) { ::uint64_t{0u} } |
| |
| , decltype(_impl_.end_) { ::uint64_t{0u} } |
| |
| }; |
| } |
| |
| FilterRange::~FilterRange() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.FilterRange) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void FilterRange::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| } |
| |
| void FilterRange::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void FilterRange::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.FilterRange) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000003u) { |
| ::memset(&_impl_.start_, 0, static_cast<::size_t>( |
| reinterpret_cast<char*>(&_impl_.end_) - |
| reinterpret_cast<char*>(&_impl_.start_)) + sizeof(_impl_.end_)); |
| } |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* FilterRange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // required uint64 start = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { |
| _Internal::set_has_start(&has_bits); |
| _impl_.start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // required uint64 end = 2; |
| case 2: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { |
| _Internal::set_has_end(&has_bits); |
| _impl_.end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* FilterRange::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.FilterRange) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required uint64 start = 1; |
| if (cached_has_bits & 0x00000001u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteUInt64ToArray( |
| 1, this->_internal_start(), target); |
| } |
| |
| // required uint64 end = 2; |
| if (cached_has_bits & 0x00000002u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteUInt64ToArray( |
| 2, this->_internal_end(), target); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.FilterRange) |
| return target; |
| } |
| |
| ::size_t FilterRange::RequiredFieldsByteSizeFallback() const { |
| // @@protoc_insertion_point(required_fields_byte_size_fallback_start:shill.mobile_operator_db.FilterRange) |
| ::size_t total_size = 0; |
| |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| // required uint64 start = 1; |
| total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( |
| this->_internal_start()); |
| } |
| |
| if ((_impl_._has_bits_[0] & 0x00000002u) != 0) { |
| // required uint64 end = 2; |
| total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( |
| this->_internal_end()); |
| } |
| |
| return total_size; |
| } |
| ::size_t FilterRange::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.FilterRange) |
| ::size_t total_size = 0; |
| |
| if (((_impl_._has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present. |
| // required uint64 start = 1; |
| total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( |
| this->_internal_start()); |
| |
| // required uint64 end = 2; |
| total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( |
| this->_internal_end()); |
| |
| } else { |
| total_size += RequiredFieldsByteSizeFallback(); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void FilterRange::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const FilterRange*>( |
| &from)); |
| } |
| |
| void FilterRange::MergeFrom(const FilterRange& from) { |
| FilterRange* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.FilterRange) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000003u) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_impl_.start_ = from._impl_.start_; |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_impl_.end_ = from._impl_.end_; |
| } |
| _this->_impl_._has_bits_[0] |= cached_has_bits; |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void FilterRange::CopyFrom(const FilterRange& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.FilterRange) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool FilterRange::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| return true; |
| } |
| |
| void FilterRange::InternalSwap(FilterRange* other) { |
| using std::swap; |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| ::PROTOBUF_NAMESPACE_ID::internal::memswap< |
| PROTOBUF_FIELD_OFFSET(FilterRange, _impl_.end_) |
| + sizeof(FilterRange::_impl_.end_) |
| - PROTOBUF_FIELD_OFFSET(FilterRange, _impl_.start_)>( |
| reinterpret_cast<char*>(&_impl_.start_), |
| reinterpret_cast<char*>(&other->_impl_.start_)); |
| } |
| |
| std::string FilterRange::GetTypeName() const { |
| return "shill.mobile_operator_db.FilterRange"; |
| } |
| |
| // =================================================================== |
| |
| class Filter::_Internal { |
| public: |
| using HasBits = decltype(std::declval<Filter>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(Filter, _impl_._has_bits_); |
| static void set_has_type(HasBits* has_bits) { |
| (*has_bits)[0] |= 4u; |
| } |
| static void set_has_regex(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_exclude_regex(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0; |
| } |
| }; |
| |
| Filter::Filter(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.Filter) |
| } |
| Filter::Filter(const Filter& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| Filter* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.range_){from._impl_.range_} |
| , decltype(_impl_.regex_) {} |
| |
| , decltype(_impl_.exclude_regex_) {} |
| |
| , decltype(_impl_.type_) {} |
| }; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| _impl_.regex_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.regex_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.regex_.Set(from._internal_regex(), _this->GetArenaForAllocation()); |
| } |
| _impl_.exclude_regex_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.exclude_regex_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { |
| _this->_impl_.exclude_regex_.Set(from._internal_exclude_regex(), _this->GetArenaForAllocation()); |
| } |
| _this->_impl_.type_ = from._impl_.type_; |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.Filter) |
| } |
| |
| inline void Filter::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.range_){arena} |
| , decltype(_impl_.regex_) {} |
| |
| , decltype(_impl_.exclude_regex_) {} |
| |
| , decltype(_impl_.type_) { 1 } |
| |
| }; |
| _impl_.regex_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.regex_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.exclude_regex_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.exclude_regex_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| } |
| |
| Filter::~Filter() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.Filter) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void Filter::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _internal_mutable_range()->~RepeatedPtrField(); |
| _impl_.regex_.Destroy(); |
| _impl_.exclude_regex_.Destroy(); |
| } |
| |
| void Filter::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void Filter::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.Filter) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| _internal_mutable_range()->Clear(); |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000007u) { |
| if (cached_has_bits & 0x00000001u) { |
| _impl_.regex_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _impl_.exclude_regex_.ClearNonDefaultToEmpty(); |
| } |
| _impl_.type_ = 1; |
| } |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* Filter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // required .shill.mobile_operator_db.Filter.Type type = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::Filter_Type_IsValid(static_cast<int>(val)))) { |
| _internal_set_type(static_cast<::shill::mobile_operator_db::Filter_Type>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); |
| } |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string regex = 2; |
| case 2: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { |
| auto str = _internal_mutable_regex(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.FilterRange range = 3; |
| case 3: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_range(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string exclude_regex = 4; |
| case 4: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { |
| auto str = _internal_mutable_exclude_regex(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* Filter::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.Filter) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required .shill.mobile_operator_db.Filter.Type type = 1; |
| if (cached_has_bits & 0x00000004u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 1, this->_internal_type(), target); |
| } |
| |
| // optional string regex = 2; |
| if (cached_has_bits & 0x00000001u) { |
| const std::string& _s = this->_internal_regex(); |
| target = stream->WriteStringMaybeAliased(2, _s, target); |
| } |
| |
| // repeated .shill.mobile_operator_db.FilterRange range = 3; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_range_size()); i < n; i++) { |
| const auto& repfield = this->_internal_range(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // optional string exclude_regex = 4; |
| if (cached_has_bits & 0x00000002u) { |
| const std::string& _s = this->_internal_exclude_regex(); |
| target = stream->WriteStringMaybeAliased(4, _s, target); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.Filter) |
| return target; |
| } |
| |
| ::size_t Filter::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.Filter) |
| ::size_t total_size = 0; |
| |
| // required .shill.mobile_operator_db.Filter.Type type = 1; |
| if ((_impl_._has_bits_[0] & 0x00000004u) != 0) { |
| total_size += 1 + |
| ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.FilterRange range = 3; |
| total_size += 1UL * this->_internal_range_size(); |
| for (const auto& msg : this->_internal_range()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000003u) { |
| // optional string regex = 2; |
| if (cached_has_bits & 0x00000001u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_regex()); |
| } |
| |
| // optional string exclude_regex = 4; |
| if (cached_has_bits & 0x00000002u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_exclude_regex()); |
| } |
| |
| } |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void Filter::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const Filter*>( |
| &from)); |
| } |
| |
| void Filter::MergeFrom(const Filter& from) { |
| Filter* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.Filter) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| _this->_internal_mutable_range()->MergeFrom(from._internal_range()); |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000007u) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_internal_set_regex(from._internal_regex()); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_internal_set_exclude_regex(from._internal_exclude_regex()); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| _this->_impl_.type_ = from._impl_.type_; |
| } |
| _this->_impl_._has_bits_[0] |= cached_has_bits; |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void Filter::CopyFrom(const Filter& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.Filter) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool Filter::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_range())) |
| return false; |
| return true; |
| } |
| |
| void Filter::InternalSwap(Filter* other) { |
| using std::swap; |
| auto* lhs_arena = GetArenaForAllocation(); |
| auto* rhs_arena = other->GetArenaForAllocation(); |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| _internal_mutable_range()->InternalSwap(other->_internal_mutable_range()); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.regex_, lhs_arena, |
| &other->_impl_.regex_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.exclude_regex_, lhs_arena, |
| &other->_impl_.exclude_regex_, rhs_arena); |
| swap(_impl_.type_, other->_impl_.type_); |
| } |
| |
| std::string Filter::GetTypeName() const { |
| return "shill.mobile_operator_db.Filter"; |
| } |
| |
| // =================================================================== |
| |
| class LocalizedName::_Internal { |
| public: |
| using HasBits = decltype(std::declval<LocalizedName>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(LocalizedName, _impl_._has_bits_); |
| static void set_has_name(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_language(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; |
| } |
| }; |
| |
| LocalizedName::LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.LocalizedName) |
| } |
| LocalizedName::LocalizedName(const LocalizedName& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| LocalizedName* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.name_) {} |
| |
| , decltype(_impl_.language_) {} |
| }; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| _impl_.name_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.name_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.name_.Set(from._internal_name(), _this->GetArenaForAllocation()); |
| } |
| _impl_.language_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.language_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { |
| _this->_impl_.language_.Set(from._internal_language(), _this->GetArenaForAllocation()); |
| } |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.LocalizedName) |
| } |
| |
| inline void LocalizedName::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.name_) {} |
| |
| , decltype(_impl_.language_) {} |
| |
| }; |
| _impl_.name_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.name_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.language_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.language_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| } |
| |
| LocalizedName::~LocalizedName() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.LocalizedName) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void LocalizedName::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _impl_.name_.Destroy(); |
| _impl_.language_.Destroy(); |
| } |
| |
| void LocalizedName::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void LocalizedName::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.LocalizedName) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000003u) { |
| if (cached_has_bits & 0x00000001u) { |
| _impl_.name_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _impl_.language_.ClearNonDefaultToEmpty(); |
| } |
| } |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* LocalizedName::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // required string name = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| auto str = _internal_mutable_name(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string language = 2; |
| case 2: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { |
| auto str = _internal_mutable_language(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* LocalizedName::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.LocalizedName) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required string name = 1; |
| if (cached_has_bits & 0x00000001u) { |
| const std::string& _s = this->_internal_name(); |
| target = stream->WriteStringMaybeAliased(1, _s, target); |
| } |
| |
| // optional string language = 2; |
| if (cached_has_bits & 0x00000002u) { |
| const std::string& _s = this->_internal_language(); |
| target = stream->WriteStringMaybeAliased(2, _s, target); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.LocalizedName) |
| return target; |
| } |
| |
| ::size_t LocalizedName::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.LocalizedName) |
| ::size_t total_size = 0; |
| |
| // required string name = 1; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_name()); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // optional string language = 2; |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000002u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_language()); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void LocalizedName::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const LocalizedName*>( |
| &from)); |
| } |
| |
| void LocalizedName::MergeFrom(const LocalizedName& from) { |
| LocalizedName* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.LocalizedName) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000003u) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_internal_set_name(from._internal_name()); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_internal_set_language(from._internal_language()); |
| } |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void LocalizedName::CopyFrom(const LocalizedName& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.LocalizedName) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool LocalizedName::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| return true; |
| } |
| |
| void LocalizedName::InternalSwap(LocalizedName* other) { |
| using std::swap; |
| auto* lhs_arena = GetArenaForAllocation(); |
| auto* rhs_arena = other->GetArenaForAllocation(); |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, lhs_arena, |
| &other->_impl_.name_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.language_, lhs_arena, |
| &other->_impl_.language_, rhs_arena); |
| } |
| |
| std::string LocalizedName::GetTypeName() const { |
| return "shill.mobile_operator_db.LocalizedName"; |
| } |
| |
| // =================================================================== |
| |
| class MobileAPN::_Internal { |
| public: |
| using HasBits = decltype(std::declval<MobileAPN>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(MobileAPN, _impl_._has_bits_); |
| static void set_has_apn(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_obsolete_gateway(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static void set_has_username(HasBits* has_bits) { |
| (*has_bits)[0] |= 4u; |
| } |
| static void set_has_password(HasBits* has_bits) { |
| (*has_bits)[0] |= 8u; |
| } |
| static void set_has_authentication(HasBits* has_bits) { |
| (*has_bits)[0] |= 16u; |
| } |
| static void set_has_obsolete_is_attach_apn(HasBits* has_bits) { |
| (*has_bits)[0] |= 32u; |
| } |
| static void set_has_ip_type(HasBits* has_bits) { |
| (*has_bits)[0] |= 128u; |
| } |
| static void set_has_is_required_by_carrier_spec(HasBits* has_bits) { |
| (*has_bits)[0] |= 64u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; |
| } |
| }; |
| |
| MobileAPN::MobileAPN(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.MobileAPN) |
| } |
| MobileAPN::MobileAPN(const MobileAPN& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| MobileAPN* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.localized_name_){from._impl_.localized_name_} |
| , decltype(_impl_.obsolete_dns_){from._impl_.obsolete_dns_} |
| , decltype(_impl_.apn_filter_){from._impl_.apn_filter_} |
| , decltype(_impl_.type_) { from._internal_type() } |
| |
| , decltype(_impl_.apn_) {} |
| |
| , decltype(_impl_.obsolete_gateway_) {} |
| |
| , decltype(_impl_.username_) {} |
| |
| , decltype(_impl_.password_) {} |
| |
| , decltype(_impl_.authentication_) {} |
| |
| , decltype(_impl_.obsolete_is_attach_apn_) {} |
| |
| , decltype(_impl_.is_required_by_carrier_spec_) {} |
| |
| , decltype(_impl_.ip_type_) {} |
| }; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| _impl_.apn_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.apn_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.apn_.Set(from._internal_apn(), _this->GetArenaForAllocation()); |
| } |
| _impl_.obsolete_gateway_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.obsolete_gateway_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { |
| _this->_impl_.obsolete_gateway_.Set(from._internal_obsolete_gateway(), _this->GetArenaForAllocation()); |
| } |
| _impl_.username_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.username_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) { |
| _this->_impl_.username_.Set(from._internal_username(), _this->GetArenaForAllocation()); |
| } |
| _impl_.password_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.password_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) { |
| _this->_impl_.password_.Set(from._internal_password(), _this->GetArenaForAllocation()); |
| } |
| ::memcpy(&_impl_.authentication_, &from._impl_.authentication_, |
| static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.ip_type_) - |
| reinterpret_cast<char*>(&_impl_.authentication_)) + sizeof(_impl_.ip_type_)); |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.MobileAPN) |
| } |
| |
| inline void MobileAPN::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.localized_name_){arena} |
| , decltype(_impl_.obsolete_dns_){arena} |
| , decltype(_impl_.apn_filter_){arena} |
| , decltype(_impl_.type_) { arena } |
| |
| , decltype(_impl_.apn_) {} |
| |
| , decltype(_impl_.obsolete_gateway_) {} |
| |
| , decltype(_impl_.username_) {} |
| |
| , decltype(_impl_.password_) {} |
| |
| , decltype(_impl_.authentication_) { 0 } |
| |
| , decltype(_impl_.obsolete_is_attach_apn_) { false } |
| |
| , decltype(_impl_.is_required_by_carrier_spec_) { false } |
| |
| , decltype(_impl_.ip_type_) { 1 } |
| |
| }; |
| _impl_.apn_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.apn_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.obsolete_gateway_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.obsolete_gateway_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.username_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.username_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.password_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.password_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| } |
| |
| MobileAPN::~MobileAPN() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.MobileAPN) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void MobileAPN::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _internal_mutable_localized_name()->~RepeatedPtrField(); |
| _internal_mutable_obsolete_dns()->~RepeatedPtrField(); |
| _internal_mutable_apn_filter()->~RepeatedPtrField(); |
| _internal_mutable_type()->~RepeatedField(); |
| _impl_.apn_.Destroy(); |
| _impl_.obsolete_gateway_.Destroy(); |
| _impl_.username_.Destroy(); |
| _impl_.password_.Destroy(); |
| } |
| |
| void MobileAPN::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void MobileAPN::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.MobileAPN) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| _internal_mutable_localized_name()->Clear(); |
| _internal_mutable_obsolete_dns()->Clear(); |
| _internal_mutable_apn_filter()->Clear(); |
| _internal_mutable_type()->Clear(); |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x0000000fu) { |
| if (cached_has_bits & 0x00000001u) { |
| _impl_.apn_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _impl_.obsolete_gateway_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| _impl_.username_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000008u) { |
| _impl_.password_.ClearNonDefaultToEmpty(); |
| } |
| } |
| if (cached_has_bits & 0x000000f0u) { |
| ::memset(&_impl_.authentication_, 0, static_cast<::size_t>( |
| reinterpret_cast<char*>(&_impl_.is_required_by_carrier_spec_) - |
| reinterpret_cast<char*>(&_impl_.authentication_)) + sizeof(_impl_.is_required_by_carrier_spec_)); |
| _impl_.ip_type_ = 1; |
| } |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* MobileAPN::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // required string apn = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| auto str = _internal_mutable_apn(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.LocalizedName localized_name = 3; |
| case 3: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_localized_name(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string OBSOLETE_gateway = 4; |
| case 4: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { |
| auto str = _internal_mutable_obsolete_gateway(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string username = 5; |
| case 5: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) { |
| auto str = _internal_mutable_username(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string password = 6; |
| case 6: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { |
| auto str = _internal_mutable_password(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated string OBSOLETE_dns = 7; |
| case 7: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| auto str = _internal_add_obsolete_dns(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional .shill.mobile_operator_db.MobileAPN.Authentication authentication = 8; |
| case 8: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) { |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::MobileAPN_Authentication_IsValid(static_cast<int>(val)))) { |
| _internal_set_authentication(static_cast<::shill::mobile_operator_db::MobileAPN_Authentication>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); |
| } |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool OBSOLETE_is_attach_apn = 9; |
| case 9: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) { |
| _Internal::set_has_obsolete_is_attach_apn(&has_bits); |
| _impl_.obsolete_is_attach_apn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional .shill.mobile_operator_db.MobileAPN.IpType ip_type = 10 [default = IPV4]; |
| case 10: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) { |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::MobileAPN_IpType_IsValid(static_cast<int>(val)))) { |
| _internal_set_ip_type(static_cast<::shill::mobile_operator_db::MobileAPN_IpType>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); |
| } |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.Filter apn_filter = 11; |
| case 11: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_apn_filter(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.MobileAPN.ApnType type = 12; |
| case 12: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::MobileAPN_ApnType_IsValid(static_cast<int>(val)))) { |
| _internal_add_type(static_cast<::shill::mobile_operator_db::MobileAPN_ApnType>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); |
| } |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<96>(ptr)); |
| } else if (static_cast<::uint8_t>(tag) == 98) { |
| ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_type(), ptr, ctx, ::shill::mobile_operator_db::MobileAPN_ApnType_IsValid, &_internal_metadata_, 12); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool is_required_by_carrier_spec = 13 [default = false]; |
| case 13: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) { |
| _Internal::set_has_is_required_by_carrier_spec(&has_bits); |
| _impl_.is_required_by_carrier_spec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* MobileAPN::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.MobileAPN) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required string apn = 1; |
| if (cached_has_bits & 0x00000001u) { |
| const std::string& _s = this->_internal_apn(); |
| target = stream->WriteStringMaybeAliased(1, _s, target); |
| } |
| |
| // repeated .shill.mobile_operator_db.LocalizedName localized_name = 3; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_localized_name_size()); i < n; i++) { |
| const auto& repfield = this->_internal_localized_name(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // optional string OBSOLETE_gateway = 4; |
| if (cached_has_bits & 0x00000002u) { |
| const std::string& _s = this->_internal_obsolete_gateway(); |
| target = stream->WriteStringMaybeAliased(4, _s, target); |
| } |
| |
| // optional string username = 5; |
| if (cached_has_bits & 0x00000004u) { |
| const std::string& _s = this->_internal_username(); |
| target = stream->WriteStringMaybeAliased(5, _s, target); |
| } |
| |
| // optional string password = 6; |
| if (cached_has_bits & 0x00000008u) { |
| const std::string& _s = this->_internal_password(); |
| target = stream->WriteStringMaybeAliased(6, _s, target); |
| } |
| |
| // repeated string OBSOLETE_dns = 7; |
| for (int i = 0, n = this->_internal_obsolete_dns_size(); i < n; ++i) { |
| const auto& s = this->_internal_obsolete_dns(i); |
| target = stream->WriteString(7, s, target); |
| } |
| |
| // optional .shill.mobile_operator_db.MobileAPN.Authentication authentication = 8; |
| if (cached_has_bits & 0x00000010u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 8, this->_internal_authentication(), target); |
| } |
| |
| // optional bool OBSOLETE_is_attach_apn = 9; |
| if (cached_has_bits & 0x00000020u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 9, this->_internal_obsolete_is_attach_apn(), target); |
| } |
| |
| // optional .shill.mobile_operator_db.MobileAPN.IpType ip_type = 10 [default = IPV4]; |
| if (cached_has_bits & 0x00000080u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 10, this->_internal_ip_type(), target); |
| } |
| |
| // repeated .shill.mobile_operator_db.Filter apn_filter = 11; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_apn_filter_size()); i < n; i++) { |
| const auto& repfield = this->_internal_apn_filter(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileAPN.ApnType type = 12; |
| for (int i = 0, n = this->_internal_type_size(); i < n; ++i) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 12, this->_internal_type(i), target); |
| } |
| |
| // optional bool is_required_by_carrier_spec = 13 [default = false]; |
| if (cached_has_bits & 0x00000040u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 13, this->_internal_is_required_by_carrier_spec(), target); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.MobileAPN) |
| return target; |
| } |
| |
| ::size_t MobileAPN::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.MobileAPN) |
| ::size_t total_size = 0; |
| |
| // required string apn = 1; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_apn()); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.LocalizedName localized_name = 3; |
| total_size += 1UL * this->_internal_localized_name_size(); |
| for (const auto& msg : this->_internal_localized_name()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // repeated string OBSOLETE_dns = 7; |
| total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_obsolete_dns().size()); |
| for (int i = 0, n = _internal_obsolete_dns().size(); i < n; ++i) { |
| total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| _internal_obsolete_dns().Get(i)); |
| } |
| |
| // repeated .shill.mobile_operator_db.Filter apn_filter = 11; |
| total_size += 1UL * this->_internal_apn_filter_size(); |
| for (const auto& msg : this->_internal_apn_filter()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileAPN.ApnType type = 12; |
| { |
| std::size_t data_size = 0; |
| auto count = static_cast<std::size_t>(this->_internal_type_size()); |
| |
| for (std::size_t i = 0; i < count; ++i) { |
| data_size += ::_pbi::WireFormatLite::EnumSize( |
| this->_internal_type(static_cast<int>(i))); |
| } |
| total_size += data_size; |
| total_size += std::size_t{1} * count; |
| } |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x000000feu) { |
| // optional string OBSOLETE_gateway = 4; |
| if (cached_has_bits & 0x00000002u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_obsolete_gateway()); |
| } |
| |
| // optional string username = 5; |
| if (cached_has_bits & 0x00000004u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_username()); |
| } |
| |
| // optional string password = 6; |
| if (cached_has_bits & 0x00000008u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_password()); |
| } |
| |
| // optional .shill.mobile_operator_db.MobileAPN.Authentication authentication = 8; |
| if (cached_has_bits & 0x00000010u) { |
| total_size += 1 + |
| ::_pbi::WireFormatLite::EnumSize(this->_internal_authentication()); |
| } |
| |
| // optional bool OBSOLETE_is_attach_apn = 9; |
| if (cached_has_bits & 0x00000020u) { |
| total_size += 2; |
| } |
| |
| // optional bool is_required_by_carrier_spec = 13 [default = false]; |
| if (cached_has_bits & 0x00000040u) { |
| total_size += 2; |
| } |
| |
| // optional .shill.mobile_operator_db.MobileAPN.IpType ip_type = 10 [default = IPV4]; |
| if (cached_has_bits & 0x00000080u) { |
| total_size += 1 + |
| ::_pbi::WireFormatLite::EnumSize(this->_internal_ip_type()); |
| } |
| |
| } |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void MobileAPN::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const MobileAPN*>( |
| &from)); |
| } |
| |
| void MobileAPN::MergeFrom(const MobileAPN& from) { |
| MobileAPN* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.MobileAPN) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| _this->_internal_mutable_localized_name()->MergeFrom(from._internal_localized_name()); |
| _this->_internal_mutable_obsolete_dns()->MergeFrom(from._internal_obsolete_dns()); |
| _this->_internal_mutable_apn_filter()->MergeFrom(from._internal_apn_filter()); |
| _this->_internal_mutable_type()->MergeFrom(from._internal_type()); |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x000000ffu) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_internal_set_apn(from._internal_apn()); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_internal_set_obsolete_gateway(from._internal_obsolete_gateway()); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| _this->_internal_set_username(from._internal_username()); |
| } |
| if (cached_has_bits & 0x00000008u) { |
| _this->_internal_set_password(from._internal_password()); |
| } |
| if (cached_has_bits & 0x00000010u) { |
| _this->_impl_.authentication_ = from._impl_.authentication_; |
| } |
| if (cached_has_bits & 0x00000020u) { |
| _this->_impl_.obsolete_is_attach_apn_ = from._impl_.obsolete_is_attach_apn_; |
| } |
| if (cached_has_bits & 0x00000040u) { |
| _this->_impl_.is_required_by_carrier_spec_ = from._impl_.is_required_by_carrier_spec_; |
| } |
| if (cached_has_bits & 0x00000080u) { |
| _this->_impl_.ip_type_ = from._impl_.ip_type_; |
| } |
| _this->_impl_._has_bits_[0] |= cached_has_bits; |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void MobileAPN::CopyFrom(const MobileAPN& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.MobileAPN) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool MobileAPN::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_localized_name())) |
| return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_apn_filter())) |
| return false; |
| return true; |
| } |
| |
| void MobileAPN::InternalSwap(MobileAPN* other) { |
| using std::swap; |
| auto* lhs_arena = GetArenaForAllocation(); |
| auto* rhs_arena = other->GetArenaForAllocation(); |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| _internal_mutable_localized_name()->InternalSwap(other->_internal_mutable_localized_name()); |
| _internal_mutable_obsolete_dns()->InternalSwap( |
| other->_internal_mutable_obsolete_dns()); |
| _internal_mutable_apn_filter()->InternalSwap(other->_internal_mutable_apn_filter()); |
| _internal_mutable_type()->InternalSwap( |
| other->_internal_mutable_type()); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.apn_, lhs_arena, |
| &other->_impl_.apn_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.obsolete_gateway_, lhs_arena, |
| &other->_impl_.obsolete_gateway_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.username_, lhs_arena, |
| &other->_impl_.username_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.password_, lhs_arena, |
| &other->_impl_.password_, rhs_arena); |
| ::PROTOBUF_NAMESPACE_ID::internal::memswap< |
| PROTOBUF_FIELD_OFFSET(MobileAPN, _impl_.ip_type_) |
| + sizeof(MobileAPN::_impl_.ip_type_) |
| - PROTOBUF_FIELD_OFFSET(MobileAPN, _impl_.authentication_)>( |
| reinterpret_cast<char*>(&_impl_.authentication_), |
| reinterpret_cast<char*>(&other->_impl_.authentication_)); |
| } |
| |
| std::string MobileAPN::GetTypeName() const { |
| return "shill.mobile_operator_db.MobileAPN"; |
| } |
| |
| // =================================================================== |
| |
| class OnlinePortal::_Internal { |
| public: |
| using HasBits = decltype(std::declval<OnlinePortal>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(OnlinePortal, _impl_._has_bits_); |
| static const ::shill::mobile_operator_db::Filter& olp_filter(const OnlinePortal* msg); |
| static void set_has_olp_filter(HasBits* has_bits) { |
| (*has_bits)[0] |= 4u; |
| } |
| static void set_has_method(HasBits* has_bits) { |
| (*has_bits)[0] |= 8u; |
| } |
| static void set_has_url(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_post_data(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000009) ^ 0x00000009) != 0; |
| } |
| }; |
| |
| const ::shill::mobile_operator_db::Filter& |
| OnlinePortal::_Internal::olp_filter(const OnlinePortal* msg) { |
| return *msg->_impl_.olp_filter_; |
| } |
| OnlinePortal::OnlinePortal(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.OnlinePortal) |
| } |
| OnlinePortal::OnlinePortal(const OnlinePortal& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| OnlinePortal* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.url_) {} |
| |
| , decltype(_impl_.post_data_) {} |
| |
| , decltype(_impl_.olp_filter_){nullptr} |
| , decltype(_impl_.method_) {} |
| }; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| _impl_.url_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.url_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.url_.Set(from._internal_url(), _this->GetArenaForAllocation()); |
| } |
| _impl_.post_data_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.post_data_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { |
| _this->_impl_.post_data_.Set(from._internal_post_data(), _this->GetArenaForAllocation()); |
| } |
| if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) { |
| _this->_impl_.olp_filter_ = new ::shill::mobile_operator_db::Filter(*from._impl_.olp_filter_); |
| } |
| _this->_impl_.method_ = from._impl_.method_; |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.OnlinePortal) |
| } |
| |
| inline void OnlinePortal::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.url_) {} |
| |
| , decltype(_impl_.post_data_) {} |
| |
| , decltype(_impl_.olp_filter_){nullptr} |
| , decltype(_impl_.method_) { 1 } |
| |
| }; |
| _impl_.url_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.url_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.post_data_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.post_data_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| } |
| |
| OnlinePortal::~OnlinePortal() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.OnlinePortal) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void OnlinePortal::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _impl_.url_.Destroy(); |
| _impl_.post_data_.Destroy(); |
| if (this != internal_default_instance()) delete _impl_.olp_filter_; |
| } |
| |
| void OnlinePortal::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void OnlinePortal::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.OnlinePortal) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x0000000fu) { |
| if (cached_has_bits & 0x00000001u) { |
| _impl_.url_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _impl_.post_data_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| ABSL_DCHECK(_impl_.olp_filter_ != nullptr); |
| _impl_.olp_filter_->Clear(); |
| } |
| _impl_.method_ = 1; |
| } |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* OnlinePortal::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // optional .shill.mobile_operator_db.Filter olp_filter = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| ptr = ctx->ParseMessage(_internal_mutable_olp_filter(), ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // required .shill.mobile_operator_db.HttpMethod method = 2; |
| case 2: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::HttpMethod_IsValid(static_cast<int>(val)))) { |
| _internal_set_method(static_cast<::shill::mobile_operator_db::HttpMethod>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); |
| } |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // required string url = 3; |
| case 3: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { |
| auto str = _internal_mutable_url(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string post_data = 4; |
| case 4: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { |
| auto str = _internal_mutable_post_data(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* OnlinePortal::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.OnlinePortal) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // optional .shill.mobile_operator_db.Filter olp_filter = 1; |
| if (cached_has_bits & 0x00000004u) { |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(1, _Internal::olp_filter(this), |
| _Internal::olp_filter(this).GetCachedSize(), target, stream); |
| } |
| |
| // required .shill.mobile_operator_db.HttpMethod method = 2; |
| if (cached_has_bits & 0x00000008u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 2, this->_internal_method(), target); |
| } |
| |
| // required string url = 3; |
| if (cached_has_bits & 0x00000001u) { |
| const std::string& _s = this->_internal_url(); |
| target = stream->WriteStringMaybeAliased(3, _s, target); |
| } |
| |
| // optional string post_data = 4; |
| if (cached_has_bits & 0x00000002u) { |
| const std::string& _s = this->_internal_post_data(); |
| target = stream->WriteStringMaybeAliased(4, _s, target); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.OnlinePortal) |
| return target; |
| } |
| |
| ::size_t OnlinePortal::RequiredFieldsByteSizeFallback() const { |
| // @@protoc_insertion_point(required_fields_byte_size_fallback_start:shill.mobile_operator_db.OnlinePortal) |
| ::size_t total_size = 0; |
| |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| // required string url = 3; |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_url()); |
| } |
| |
| if ((_impl_._has_bits_[0] & 0x00000008u) != 0) { |
| // required .shill.mobile_operator_db.HttpMethod method = 2; |
| total_size += 1 + |
| ::_pbi::WireFormatLite::EnumSize(this->_internal_method()); |
| } |
| |
| return total_size; |
| } |
| ::size_t OnlinePortal::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.OnlinePortal) |
| ::size_t total_size = 0; |
| |
| if (((_impl_._has_bits_[0] & 0x00000009) ^ 0x00000009) == 0) { // All required fields are present. |
| // required string url = 3; |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_url()); |
| |
| // required .shill.mobile_operator_db.HttpMethod method = 2; |
| total_size += 1 + |
| ::_pbi::WireFormatLite::EnumSize(this->_internal_method()); |
| |
| } else { |
| total_size += RequiredFieldsByteSizeFallback(); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000006u) { |
| // optional string post_data = 4; |
| if (cached_has_bits & 0x00000002u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_post_data()); |
| } |
| |
| // optional .shill.mobile_operator_db.Filter olp_filter = 1; |
| if (cached_has_bits & 0x00000004u) { |
| total_size += 1 + |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( |
| *_impl_.olp_filter_); |
| } |
| |
| } |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void OnlinePortal::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const OnlinePortal*>( |
| &from)); |
| } |
| |
| void OnlinePortal::MergeFrom(const OnlinePortal& from) { |
| OnlinePortal* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.OnlinePortal) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x0000000fu) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_internal_set_url(from._internal_url()); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_internal_set_post_data(from._internal_post_data()); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| _this->_internal_mutable_olp_filter()->::shill::mobile_operator_db::Filter::MergeFrom( |
| from._internal_olp_filter()); |
| } |
| if (cached_has_bits & 0x00000008u) { |
| _this->_impl_.method_ = from._impl_.method_; |
| } |
| _this->_impl_._has_bits_[0] |= cached_has_bits; |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void OnlinePortal::CopyFrom(const OnlinePortal& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.OnlinePortal) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool OnlinePortal::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| if ((_impl_._has_bits_[0] & 0x00000004u) != 0) { |
| if (!_impl_.olp_filter_->IsInitialized()) return false; |
| } |
| return true; |
| } |
| |
| void OnlinePortal::InternalSwap(OnlinePortal* other) { |
| using std::swap; |
| auto* lhs_arena = GetArenaForAllocation(); |
| auto* rhs_arena = other->GetArenaForAllocation(); |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.url_, lhs_arena, |
| &other->_impl_.url_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.post_data_, lhs_arena, |
| &other->_impl_.post_data_, rhs_arena); |
| ::PROTOBUF_NAMESPACE_ID::internal::memswap< |
| PROTOBUF_FIELD_OFFSET(OnlinePortal, _impl_.method_) |
| + sizeof(OnlinePortal::_impl_.method_) |
| - PROTOBUF_FIELD_OFFSET(OnlinePortal, _impl_.olp_filter_)>( |
| reinterpret_cast<char*>(&_impl_.olp_filter_), |
| reinterpret_cast<char*>(&other->_impl_.olp_filter_)); |
| } |
| |
| std::string OnlinePortal::GetTypeName() const { |
| return "shill.mobile_operator_db.OnlinePortal"; |
| } |
| |
| // =================================================================== |
| |
| class Data::_Internal { |
| public: |
| using HasBits = decltype(std::declval<Data>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(Data, _impl_._has_bits_); |
| static void set_has_uuid(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_country(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static void set_has_requires_roaming(HasBits* has_bits) { |
| (*has_bits)[0] |= 16u; |
| } |
| static void set_has_mtu(HasBits* has_bits) { |
| (*has_bits)[0] |= 8u; |
| } |
| static void set_has_prioritizes_name(HasBits* has_bits) { |
| (*has_bits)[0] |= 32u; |
| } |
| static void set_has_tethering_allowed(HasBits* has_bits) { |
| (*has_bits)[0] |= 64u; |
| } |
| static void set_has_use_dun_apn_as_default(HasBits* has_bits) { |
| (*has_bits)[0] |= 128u; |
| } |
| static void set_has_mhs_entitlement_url(HasBits* has_bits) { |
| (*has_bits)[0] |= 4u; |
| } |
| static void set_has_mhs_entitlement_method(HasBits* has_bits) { |
| (*has_bits)[0] |= 256u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; |
| } |
| }; |
| |
| Data::Data(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.Data) |
| } |
| Data::Data(const Data& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| Data* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.localized_name_){from._impl_.localized_name_} |
| , decltype(_impl_.olp_){from._impl_.olp_} |
| , decltype(_impl_.roaming_filter_){from._impl_.roaming_filter_} |
| , decltype(_impl_.mhs_entitlement_param_) { from._internal_mhs_entitlement_param() } |
| |
| , decltype(_impl_.mccmnc_){from._impl_.mccmnc_} |
| , decltype(_impl_.mobile_apn_){from._impl_.mobile_apn_} |
| , decltype(_impl_.uuid_) {} |
| |
| , decltype(_impl_.country_) {} |
| |
| , decltype(_impl_.mhs_entitlement_url_) {} |
| |
| , decltype(_impl_.mtu_) {} |
| |
| , decltype(_impl_.requires_roaming_) {} |
| |
| , decltype(_impl_.prioritizes_name_) {} |
| |
| , decltype(_impl_.tethering_allowed_) {} |
| |
| , decltype(_impl_.use_dun_apn_as_default_) {} |
| |
| , decltype(_impl_.mhs_entitlement_method_) {} |
| }; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| _impl_.uuid_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.uuid_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.uuid_.Set(from._internal_uuid(), _this->GetArenaForAllocation()); |
| } |
| _impl_.country_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.country_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) { |
| _this->_impl_.country_.Set(from._internal_country(), _this->GetArenaForAllocation()); |
| } |
| _impl_.mhs_entitlement_url_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.mhs_entitlement_url_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) { |
| _this->_impl_.mhs_entitlement_url_.Set(from._internal_mhs_entitlement_url(), _this->GetArenaForAllocation()); |
| } |
| ::memcpy(&_impl_.mtu_, &from._impl_.mtu_, |
| static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.mhs_entitlement_method_) - |
| reinterpret_cast<char*>(&_impl_.mtu_)) + sizeof(_impl_.mhs_entitlement_method_)); |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.Data) |
| } |
| |
| inline void Data::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.localized_name_){arena} |
| , decltype(_impl_.olp_){arena} |
| , decltype(_impl_.roaming_filter_){arena} |
| , decltype(_impl_.mhs_entitlement_param_) { arena } |
| |
| , decltype(_impl_.mccmnc_){arena} |
| , decltype(_impl_.mobile_apn_){arena} |
| , decltype(_impl_.uuid_) {} |
| |
| , decltype(_impl_.country_) {} |
| |
| , decltype(_impl_.mhs_entitlement_url_) {} |
| |
| , decltype(_impl_.mtu_) { 0 } |
| |
| , decltype(_impl_.requires_roaming_) { false } |
| |
| , decltype(_impl_.prioritizes_name_) { false } |
| |
| , decltype(_impl_.tethering_allowed_) { false } |
| |
| , decltype(_impl_.use_dun_apn_as_default_) { false } |
| |
| , decltype(_impl_.mhs_entitlement_method_) { 2 } |
| |
| }; |
| _impl_.uuid_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.uuid_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.country_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.country_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.mhs_entitlement_url_.InitDefault(); |
| #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| _impl_.mhs_entitlement_url_.Set("", GetArenaForAllocation()); |
| #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING |
| } |
| |
| Data::~Data() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.Data) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void Data::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _internal_mutable_localized_name()->~RepeatedPtrField(); |
| _internal_mutable_olp()->~RepeatedPtrField(); |
| _internal_mutable_roaming_filter()->~RepeatedPtrField(); |
| _internal_mutable_mhs_entitlement_param()->~RepeatedField(); |
| _internal_mutable_mccmnc()->~RepeatedPtrField(); |
| _internal_mutable_mobile_apn()->~RepeatedPtrField(); |
| _impl_.uuid_.Destroy(); |
| _impl_.country_.Destroy(); |
| _impl_.mhs_entitlement_url_.Destroy(); |
| } |
| |
| void Data::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void Data::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.Data) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| _internal_mutable_localized_name()->Clear(); |
| _internal_mutable_olp()->Clear(); |
| _internal_mutable_roaming_filter()->Clear(); |
| _internal_mutable_mhs_entitlement_param()->Clear(); |
| _internal_mutable_mccmnc()->Clear(); |
| _internal_mutable_mobile_apn()->Clear(); |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000007u) { |
| if (cached_has_bits & 0x00000001u) { |
| _impl_.uuid_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _impl_.country_.ClearNonDefaultToEmpty(); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| _impl_.mhs_entitlement_url_.ClearNonDefaultToEmpty(); |
| } |
| } |
| if (cached_has_bits & 0x000000f8u) { |
| ::memset(&_impl_.mtu_, 0, static_cast<::size_t>( |
| reinterpret_cast<char*>(&_impl_.use_dun_apn_as_default_) - |
| reinterpret_cast<char*>(&_impl_.mtu_)) + sizeof(_impl_.use_dun_apn_as_default_)); |
| } |
| _impl_.mhs_entitlement_method_ = 2; |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* Data::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // required string uuid = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| auto str = _internal_mutable_uuid(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string country = 3; |
| case 3: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { |
| auto str = _internal_mutable_country(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.LocalizedName localized_name = 4; |
| case 4: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_localized_name(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool requires_roaming = 5 [default = false]; |
| case 5: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) { |
| _Internal::set_has_requires_roaming(&has_bits); |
| _impl_.requires_roaming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.OnlinePortal olp = 6; |
| case 6: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_olp(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional int32 mtu = 7; |
| case 7: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) { |
| _Internal::set_has_mtu(&has_bits); |
| _impl_.mtu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool prioritizes_name = 8 [default = false]; |
| case 8: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) { |
| _Internal::set_has_prioritizes_name(&has_bits); |
| _impl_.prioritizes_name_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.Filter roaming_filter = 9; |
| case 9: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_roaming_filter(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool tethering_allowed = 10; |
| case 10: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) { |
| _Internal::set_has_tethering_allowed(&has_bits); |
| _impl_.tethering_allowed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool use_dun_apn_as_default = 11; |
| case 11: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) { |
| _Internal::set_has_use_dun_apn_as_default(&has_bits); |
| _impl_.use_dun_apn_as_default_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional string mhs_entitlement_url = 12; |
| case 12: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 98)) { |
| auto str = _internal_mutable_mhs_entitlement_url(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.Data.EntitlementParam mhs_entitlement_param = 13; |
| case 13: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::Data_EntitlementParam_IsValid(static_cast<int>(val)))) { |
| _internal_add_mhs_entitlement_param(static_cast<::shill::mobile_operator_db::Data_EntitlementParam>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields()); |
| } |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<104>(ptr)); |
| } else if (static_cast<::uint8_t>(tag) == 106) { |
| ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_mhs_entitlement_param(), ptr, ctx, ::shill::mobile_operator_db::Data_EntitlementParam_IsValid, &_internal_metadata_, 13); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional .shill.mobile_operator_db.HttpMethod mhs_entitlement_method = 14 [default = POST]; |
| case 14: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) { |
| ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); |
| CHK_(ptr); |
| if (PROTOBUF_PREDICT_TRUE(::shill::mobile_operator_db::HttpMethod_IsValid(static_cast<int>(val)))) { |
| _internal_set_mhs_entitlement_method(static_cast<::shill::mobile_operator_db::HttpMethod>(val)); |
| } else { |
| ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields()); |
| } |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated string mccmnc = 21; |
| case 21: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 170)) { |
| ptr -= 2; |
| do { |
| ptr += 2; |
| auto str = _internal_add_mccmnc(); |
| ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<170>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.MobileAPN mobile_apn = 22; |
| case 22: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 178)) { |
| ptr -= 2; |
| do { |
| ptr += 2; |
| ptr = ctx->ParseMessage(_internal_add_mobile_apn(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<178>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* Data::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.Data) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required string uuid = 1; |
| if (cached_has_bits & 0x00000001u) { |
| const std::string& _s = this->_internal_uuid(); |
| target = stream->WriteStringMaybeAliased(1, _s, target); |
| } |
| |
| // optional string country = 3; |
| if (cached_has_bits & 0x00000002u) { |
| const std::string& _s = this->_internal_country(); |
| target = stream->WriteStringMaybeAliased(3, _s, target); |
| } |
| |
| // repeated .shill.mobile_operator_db.LocalizedName localized_name = 4; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_localized_name_size()); i < n; i++) { |
| const auto& repfield = this->_internal_localized_name(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // optional bool requires_roaming = 5 [default = false]; |
| if (cached_has_bits & 0x00000010u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 5, this->_internal_requires_roaming(), target); |
| } |
| |
| // repeated .shill.mobile_operator_db.OnlinePortal olp = 6; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_olp_size()); i < n; i++) { |
| const auto& repfield = this->_internal_olp(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // optional int32 mtu = 7; |
| if (cached_has_bits & 0x00000008u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteInt32ToArray( |
| 7, this->_internal_mtu(), target); |
| } |
| |
| // optional bool prioritizes_name = 8 [default = false]; |
| if (cached_has_bits & 0x00000020u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 8, this->_internal_prioritizes_name(), target); |
| } |
| |
| // repeated .shill.mobile_operator_db.Filter roaming_filter = 9; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_roaming_filter_size()); i < n; i++) { |
| const auto& repfield = this->_internal_roaming_filter(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(9, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // optional bool tethering_allowed = 10; |
| if (cached_has_bits & 0x00000040u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 10, this->_internal_tethering_allowed(), target); |
| } |
| |
| // optional bool use_dun_apn_as_default = 11; |
| if (cached_has_bits & 0x00000080u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 11, this->_internal_use_dun_apn_as_default(), target); |
| } |
| |
| // optional string mhs_entitlement_url = 12; |
| if (cached_has_bits & 0x00000004u) { |
| const std::string& _s = this->_internal_mhs_entitlement_url(); |
| target = stream->WriteStringMaybeAliased(12, _s, target); |
| } |
| |
| // repeated .shill.mobile_operator_db.Data.EntitlementParam mhs_entitlement_param = 13; |
| for (int i = 0, n = this->_internal_mhs_entitlement_param_size(); i < n; ++i) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 13, this->_internal_mhs_entitlement_param(i), target); |
| } |
| |
| // optional .shill.mobile_operator_db.HttpMethod mhs_entitlement_method = 14 [default = POST]; |
| if (cached_has_bits & 0x00000100u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteEnumToArray( |
| 14, this->_internal_mhs_entitlement_method(), target); |
| } |
| |
| // repeated string mccmnc = 21; |
| for (int i = 0, n = this->_internal_mccmnc_size(); i < n; ++i) { |
| const auto& s = this->_internal_mccmnc(i); |
| target = stream->WriteString(21, s, target); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileAPN mobile_apn = 22; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_mobile_apn_size()); i < n; i++) { |
| const auto& repfield = this->_internal_mobile_apn(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(22, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.Data) |
| return target; |
| } |
| |
| ::size_t Data::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.Data) |
| ::size_t total_size = 0; |
| |
| // required string uuid = 1; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_uuid()); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.LocalizedName localized_name = 4; |
| total_size += 1UL * this->_internal_localized_name_size(); |
| for (const auto& msg : this->_internal_localized_name()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // repeated .shill.mobile_operator_db.OnlinePortal olp = 6; |
| total_size += 1UL * this->_internal_olp_size(); |
| for (const auto& msg : this->_internal_olp()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // repeated .shill.mobile_operator_db.Filter roaming_filter = 9; |
| total_size += 1UL * this->_internal_roaming_filter_size(); |
| for (const auto& msg : this->_internal_roaming_filter()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // repeated .shill.mobile_operator_db.Data.EntitlementParam mhs_entitlement_param = 13; |
| { |
| std::size_t data_size = 0; |
| auto count = static_cast<std::size_t>(this->_internal_mhs_entitlement_param_size()); |
| |
| for (std::size_t i = 0; i < count; ++i) { |
| data_size += ::_pbi::WireFormatLite::EnumSize( |
| this->_internal_mhs_entitlement_param(static_cast<int>(i))); |
| } |
| total_size += data_size; |
| total_size += std::size_t{1} * count; |
| } |
| |
| // repeated string mccmnc = 21; |
| total_size += 2 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_mccmnc().size()); |
| for (int i = 0, n = _internal_mccmnc().size(); i < n; ++i) { |
| total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| _internal_mccmnc().Get(i)); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileAPN mobile_apn = 22; |
| total_size += 2UL * this->_internal_mobile_apn_size(); |
| for (const auto& msg : this->_internal_mobile_apn()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x000000feu) { |
| // optional string country = 3; |
| if (cached_has_bits & 0x00000002u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_country()); |
| } |
| |
| // optional string mhs_entitlement_url = 12; |
| if (cached_has_bits & 0x00000004u) { |
| total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( |
| this->_internal_mhs_entitlement_url()); |
| } |
| |
| // optional int32 mtu = 7; |
| if (cached_has_bits & 0x00000008u) { |
| total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( |
| this->_internal_mtu()); |
| } |
| |
| // optional bool requires_roaming = 5 [default = false]; |
| if (cached_has_bits & 0x00000010u) { |
| total_size += 2; |
| } |
| |
| // optional bool prioritizes_name = 8 [default = false]; |
| if (cached_has_bits & 0x00000020u) { |
| total_size += 2; |
| } |
| |
| // optional bool tethering_allowed = 10; |
| if (cached_has_bits & 0x00000040u) { |
| total_size += 2; |
| } |
| |
| // optional bool use_dun_apn_as_default = 11; |
| if (cached_has_bits & 0x00000080u) { |
| total_size += 2; |
| } |
| |
| } |
| // optional .shill.mobile_operator_db.HttpMethod mhs_entitlement_method = 14 [default = POST]; |
| if (cached_has_bits & 0x00000100u) { |
| total_size += 1 + |
| ::_pbi::WireFormatLite::EnumSize(this->_internal_mhs_entitlement_method()); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void Data::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const Data*>( |
| &from)); |
| } |
| |
| void Data::MergeFrom(const Data& from) { |
| Data* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.Data) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| _this->_internal_mutable_localized_name()->MergeFrom(from._internal_localized_name()); |
| _this->_internal_mutable_olp()->MergeFrom(from._internal_olp()); |
| _this->_internal_mutable_roaming_filter()->MergeFrom(from._internal_roaming_filter()); |
| _this->_internal_mutable_mhs_entitlement_param()->MergeFrom(from._internal_mhs_entitlement_param()); |
| _this->_internal_mutable_mccmnc()->MergeFrom(from._internal_mccmnc()); |
| _this->_internal_mutable_mobile_apn()->MergeFrom(from._internal_mobile_apn()); |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x000000ffu) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_internal_set_uuid(from._internal_uuid()); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_internal_set_country(from._internal_country()); |
| } |
| if (cached_has_bits & 0x00000004u) { |
| _this->_internal_set_mhs_entitlement_url(from._internal_mhs_entitlement_url()); |
| } |
| if (cached_has_bits & 0x00000008u) { |
| _this->_impl_.mtu_ = from._impl_.mtu_; |
| } |
| if (cached_has_bits & 0x00000010u) { |
| _this->_impl_.requires_roaming_ = from._impl_.requires_roaming_; |
| } |
| if (cached_has_bits & 0x00000020u) { |
| _this->_impl_.prioritizes_name_ = from._impl_.prioritizes_name_; |
| } |
| if (cached_has_bits & 0x00000040u) { |
| _this->_impl_.tethering_allowed_ = from._impl_.tethering_allowed_; |
| } |
| if (cached_has_bits & 0x00000080u) { |
| _this->_impl_.use_dun_apn_as_default_ = from._impl_.use_dun_apn_as_default_; |
| } |
| _this->_impl_._has_bits_[0] |= cached_has_bits; |
| } |
| if (cached_has_bits & 0x00000100u) { |
| _this->_internal_set_mhs_entitlement_method(from._internal_mhs_entitlement_method()); |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void Data::CopyFrom(const Data& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.Data) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool Data::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_localized_name())) |
| return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_olp())) |
| return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_roaming_filter())) |
| return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_mobile_apn())) |
| return false; |
| return true; |
| } |
| |
| void Data::InternalSwap(Data* other) { |
| using std::swap; |
| auto* lhs_arena = GetArenaForAllocation(); |
| auto* rhs_arena = other->GetArenaForAllocation(); |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| _internal_mutable_localized_name()->InternalSwap(other->_internal_mutable_localized_name()); |
| _internal_mutable_olp()->InternalSwap(other->_internal_mutable_olp()); |
| _internal_mutable_roaming_filter()->InternalSwap(other->_internal_mutable_roaming_filter()); |
| _internal_mutable_mhs_entitlement_param()->InternalSwap( |
| other->_internal_mutable_mhs_entitlement_param()); |
| _internal_mutable_mccmnc()->InternalSwap( |
| other->_internal_mutable_mccmnc()); |
| _internal_mutable_mobile_apn()->InternalSwap(other->_internal_mutable_mobile_apn()); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uuid_, lhs_arena, |
| &other->_impl_.uuid_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.country_, lhs_arena, |
| &other->_impl_.country_, rhs_arena); |
| ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.mhs_entitlement_url_, lhs_arena, |
| &other->_impl_.mhs_entitlement_url_, rhs_arena); |
| ::PROTOBUF_NAMESPACE_ID::internal::memswap< |
| PROTOBUF_FIELD_OFFSET(Data, _impl_.mhs_entitlement_method_) |
| + sizeof(Data::_impl_.mhs_entitlement_method_) |
| - PROTOBUF_FIELD_OFFSET(Data, _impl_.mtu_)>( |
| reinterpret_cast<char*>(&_impl_.mtu_), |
| reinterpret_cast<char*>(&other->_impl_.mtu_)); |
| } |
| |
| std::string Data::GetTypeName() const { |
| return "shill.mobile_operator_db.Data"; |
| } |
| |
| // =================================================================== |
| |
| class MobileVirtualNetworkOperator::_Internal { |
| public: |
| using HasBits = decltype(std::declval<MobileVirtualNetworkOperator>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(MobileVirtualNetworkOperator, _impl_._has_bits_); |
| static const ::shill::mobile_operator_db::Data& data(const MobileVirtualNetworkOperator* msg); |
| static void set_has_data(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; |
| } |
| }; |
| |
| const ::shill::mobile_operator_db::Data& |
| MobileVirtualNetworkOperator::_Internal::data(const MobileVirtualNetworkOperator* msg) { |
| return *msg->_impl_.data_; |
| } |
| MobileVirtualNetworkOperator::MobileVirtualNetworkOperator(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| } |
| MobileVirtualNetworkOperator::MobileVirtualNetworkOperator(const MobileVirtualNetworkOperator& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| MobileVirtualNetworkOperator* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.mvno_filter_){from._impl_.mvno_filter_} |
| , decltype(_impl_.data_){nullptr}}; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.data_ = new ::shill::mobile_operator_db::Data(*from._impl_.data_); |
| } |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| } |
| |
| inline void MobileVirtualNetworkOperator::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.mvno_filter_){arena} |
| , decltype(_impl_.data_){nullptr} |
| }; |
| } |
| |
| MobileVirtualNetworkOperator::~MobileVirtualNetworkOperator() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void MobileVirtualNetworkOperator::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _internal_mutable_mvno_filter()->~RepeatedPtrField(); |
| if (this != internal_default_instance()) delete _impl_.data_; |
| } |
| |
| void MobileVirtualNetworkOperator::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void MobileVirtualNetworkOperator::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| _internal_mutable_mvno_filter()->Clear(); |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000001u) { |
| ABSL_DCHECK(_impl_.data_ != nullptr); |
| _impl_.data_->Clear(); |
| } |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* MobileVirtualNetworkOperator::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // repeated .shill.mobile_operator_db.Filter mvno_filter = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_mvno_filter(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // required .shill.mobile_operator_db.Data data = 2; |
| case 2: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { |
| ptr = ctx->ParseMessage(_internal_mutable_data(), ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* MobileVirtualNetworkOperator::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.Filter mvno_filter = 1; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_mvno_filter_size()); i < n; i++) { |
| const auto& repfield = this->_internal_mvno_filter(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required .shill.mobile_operator_db.Data data = 2; |
| if (cached_has_bits & 0x00000001u) { |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(2, _Internal::data(this), |
| _Internal::data(this).GetCachedSize(), target, stream); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| return target; |
| } |
| |
| ::size_t MobileVirtualNetworkOperator::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| ::size_t total_size = 0; |
| |
| // required .shill.mobile_operator_db.Data data = 2; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| total_size += 1 + |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( |
| *_impl_.data_); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.Filter mvno_filter = 1; |
| total_size += 1UL * this->_internal_mvno_filter_size(); |
| for (const auto& msg : this->_internal_mvno_filter()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void MobileVirtualNetworkOperator::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const MobileVirtualNetworkOperator*>( |
| &from)); |
| } |
| |
| void MobileVirtualNetworkOperator::MergeFrom(const MobileVirtualNetworkOperator& from) { |
| MobileVirtualNetworkOperator* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| _this->_internal_mutable_mvno_filter()->MergeFrom(from._internal_mvno_filter()); |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_internal_mutable_data()->::shill::mobile_operator_db::Data::MergeFrom( |
| from._internal_data()); |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void MobileVirtualNetworkOperator::CopyFrom(const MobileVirtualNetworkOperator& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.MobileVirtualNetworkOperator) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool MobileVirtualNetworkOperator::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_mvno_filter())) |
| return false; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| if (!_impl_.data_->IsInitialized()) return false; |
| } |
| return true; |
| } |
| |
| void MobileVirtualNetworkOperator::InternalSwap(MobileVirtualNetworkOperator* other) { |
| using std::swap; |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| _internal_mutable_mvno_filter()->InternalSwap(other->_internal_mutable_mvno_filter()); |
| swap(_impl_.data_, other->_impl_.data_); |
| } |
| |
| std::string MobileVirtualNetworkOperator::GetTypeName() const { |
| return "shill.mobile_operator_db.MobileVirtualNetworkOperator"; |
| } |
| |
| // =================================================================== |
| |
| class MobileNetworkOperator::_Internal { |
| public: |
| using HasBits = decltype(std::declval<MobileNetworkOperator>()._impl_._has_bits_); |
| static constexpr ::int32_t kHasBitsOffset = |
| 8 * PROTOBUF_FIELD_OFFSET(MobileNetworkOperator, _impl_._has_bits_); |
| static const ::shill::mobile_operator_db::Data& data(const MobileNetworkOperator* msg); |
| static void set_has_data(HasBits* has_bits) { |
| (*has_bits)[0] |= 1u; |
| } |
| static void set_has_earmarked(HasBits* has_bits) { |
| (*has_bits)[0] |= 2u; |
| } |
| static bool MissingRequiredFields(const HasBits& has_bits) { |
| return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; |
| } |
| }; |
| |
| const ::shill::mobile_operator_db::Data& |
| MobileNetworkOperator::_Internal::data(const MobileNetworkOperator* msg) { |
| return *msg->_impl_.data_; |
| } |
| MobileNetworkOperator::MobileNetworkOperator(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.MobileNetworkOperator) |
| } |
| MobileNetworkOperator::MobileNetworkOperator(const MobileNetworkOperator& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| MobileNetworkOperator* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){from._impl_._has_bits_} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.mvno_){from._impl_.mvno_} |
| , decltype(_impl_.data_){nullptr} |
| , decltype(_impl_.earmarked_) {} |
| }; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { |
| _this->_impl_.data_ = new ::shill::mobile_operator_db::Data(*from._impl_.data_); |
| } |
| _this->_impl_.earmarked_ = from._impl_.earmarked_; |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.MobileNetworkOperator) |
| } |
| |
| inline void MobileNetworkOperator::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_._has_bits_){} |
| , /*decltype(_impl_._cached_size_)*/{} |
| , decltype(_impl_.mvno_){arena} |
| , decltype(_impl_.data_){nullptr} |
| , decltype(_impl_.earmarked_) { false } |
| |
| }; |
| } |
| |
| MobileNetworkOperator::~MobileNetworkOperator() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.MobileNetworkOperator) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void MobileNetworkOperator::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _internal_mutable_mvno()->~RepeatedPtrField(); |
| if (this != internal_default_instance()) delete _impl_.data_; |
| } |
| |
| void MobileNetworkOperator::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void MobileNetworkOperator::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.MobileNetworkOperator) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| _internal_mutable_mvno()->Clear(); |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000001u) { |
| ABSL_DCHECK(_impl_.data_ != nullptr); |
| _impl_.data_->Clear(); |
| } |
| _impl_.earmarked_ = false; |
| _impl_._has_bits_.Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* MobileNetworkOperator::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| _Internal::HasBits has_bits{}; |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // required .shill.mobile_operator_db.Data data = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| ptr = ctx->ParseMessage(_internal_mutable_data(), ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.MobileVirtualNetworkOperator mvno = 2; |
| case 2: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_mvno(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // optional bool earmarked = 3; |
| case 3: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) { |
| _Internal::set_has_earmarked(&has_bits); |
| _impl_.earmarked_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); |
| CHK_(ptr); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| _impl_._has_bits_.Or(has_bits); |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* MobileNetworkOperator::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.MobileNetworkOperator) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| cached_has_bits = _impl_._has_bits_[0]; |
| // required .shill.mobile_operator_db.Data data = 1; |
| if (cached_has_bits & 0x00000001u) { |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(1, _Internal::data(this), |
| _Internal::data(this).GetCachedSize(), target, stream); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileVirtualNetworkOperator mvno = 2; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_mvno_size()); i < n; i++) { |
| const auto& repfield = this->_internal_mvno(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // optional bool earmarked = 3; |
| if (cached_has_bits & 0x00000002u) { |
| target = stream->EnsureSpace(target); |
| target = ::_pbi::WireFormatLite::WriteBoolToArray( |
| 3, this->_internal_earmarked(), target); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.MobileNetworkOperator) |
| return target; |
| } |
| |
| ::size_t MobileNetworkOperator::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.MobileNetworkOperator) |
| ::size_t total_size = 0; |
| |
| // required .shill.mobile_operator_db.Data data = 1; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| total_size += 1 + |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( |
| *_impl_.data_); |
| } |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.MobileVirtualNetworkOperator mvno = 2; |
| total_size += 1UL * this->_internal_mvno_size(); |
| for (const auto& msg : this->_internal_mvno()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // optional bool earmarked = 3; |
| cached_has_bits = _impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000002u) { |
| total_size += 2; |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void MobileNetworkOperator::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const MobileNetworkOperator*>( |
| &from)); |
| } |
| |
| void MobileNetworkOperator::MergeFrom(const MobileNetworkOperator& from) { |
| MobileNetworkOperator* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.MobileNetworkOperator) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| _this->_internal_mutable_mvno()->MergeFrom(from._internal_mvno()); |
| cached_has_bits = from._impl_._has_bits_[0]; |
| if (cached_has_bits & 0x00000003u) { |
| if (cached_has_bits & 0x00000001u) { |
| _this->_internal_mutable_data()->::shill::mobile_operator_db::Data::MergeFrom( |
| from._internal_data()); |
| } |
| if (cached_has_bits & 0x00000002u) { |
| _this->_impl_.earmarked_ = from._impl_.earmarked_; |
| } |
| _this->_impl_._has_bits_[0] |= cached_has_bits; |
| } |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void MobileNetworkOperator::CopyFrom(const MobileNetworkOperator& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.MobileNetworkOperator) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool MobileNetworkOperator::IsInitialized() const { |
| if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_mvno())) |
| return false; |
| if ((_impl_._has_bits_[0] & 0x00000001u) != 0) { |
| if (!_impl_.data_->IsInitialized()) return false; |
| } |
| return true; |
| } |
| |
| void MobileNetworkOperator::InternalSwap(MobileNetworkOperator* other) { |
| using std::swap; |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); |
| _internal_mutable_mvno()->InternalSwap(other->_internal_mutable_mvno()); |
| ::PROTOBUF_NAMESPACE_ID::internal::memswap< |
| PROTOBUF_FIELD_OFFSET(MobileNetworkOperator, _impl_.earmarked_) |
| + sizeof(MobileNetworkOperator::_impl_.earmarked_) |
| - PROTOBUF_FIELD_OFFSET(MobileNetworkOperator, _impl_.data_)>( |
| reinterpret_cast<char*>(&_impl_.data_), |
| reinterpret_cast<char*>(&other->_impl_.data_)); |
| } |
| |
| std::string MobileNetworkOperator::GetTypeName() const { |
| return "shill.mobile_operator_db.MobileNetworkOperator"; |
| } |
| |
| // =================================================================== |
| |
| class MobileOperatorDB::_Internal { |
| public: |
| }; |
| |
| MobileOperatorDB::MobileOperatorDB(::PROTOBUF_NAMESPACE_ID::Arena* arena) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { |
| SharedCtor(arena); |
| // @@protoc_insertion_point(arena_constructor:shill.mobile_operator_db.MobileOperatorDB) |
| } |
| MobileOperatorDB::MobileOperatorDB(const MobileOperatorDB& from) |
| : ::PROTOBUF_NAMESPACE_ID::MessageLite() { |
| MobileOperatorDB* const _this = this; (void)_this; |
| new (&_impl_) Impl_{ |
| decltype(_impl_.mno_){from._impl_.mno_} |
| , decltype(_impl_.mvno_){from._impl_.mvno_} |
| , /*decltype(_impl_._cached_size_)*/{}}; |
| |
| _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| // @@protoc_insertion_point(copy_constructor:shill.mobile_operator_db.MobileOperatorDB) |
| } |
| |
| inline void MobileOperatorDB::SharedCtor(::_pb::Arena* arena) { |
| (void)arena; |
| new (&_impl_) Impl_{ |
| decltype(_impl_.mno_){arena} |
| , decltype(_impl_.mvno_){arena} |
| , /*decltype(_impl_._cached_size_)*/{} |
| }; |
| } |
| |
| MobileOperatorDB::~MobileOperatorDB() { |
| // @@protoc_insertion_point(destructor:shill.mobile_operator_db.MobileOperatorDB) |
| if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) { |
| (void)arena; |
| return; |
| } |
| SharedDtor(); |
| } |
| |
| inline void MobileOperatorDB::SharedDtor() { |
| ABSL_DCHECK(GetArenaForAllocation() == nullptr); |
| _internal_mutable_mno()->~RepeatedPtrField(); |
| _internal_mutable_mvno()->~RepeatedPtrField(); |
| } |
| |
| void MobileOperatorDB::SetCachedSize(int size) const { |
| _impl_._cached_size_.Set(size); |
| } |
| |
| void MobileOperatorDB::Clear() { |
| // @@protoc_insertion_point(message_clear_start:shill.mobile_operator_db.MobileOperatorDB) |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| _internal_mutable_mno()->Clear(); |
| _internal_mutable_mvno()->Clear(); |
| _internal_metadata_.Clear<std::string>(); |
| } |
| |
| const char* MobileOperatorDB::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { |
| #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure |
| while (!ctx->Done(&ptr)) { |
| ::uint32_t tag; |
| ptr = ::_pbi::ReadTag(ptr, &tag); |
| switch (tag >> 3) { |
| // repeated .shill.mobile_operator_db.MobileNetworkOperator mno = 1; |
| case 1: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_mno(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| // repeated .shill.mobile_operator_db.MobileVirtualNetworkOperator mvno = 3; |
| case 3: |
| if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { |
| ptr -= 1; |
| do { |
| ptr += 1; |
| ptr = ctx->ParseMessage(_internal_add_mvno(), ptr); |
| CHK_(ptr); |
| if (!ctx->DataAvailable(ptr)) break; |
| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); |
| } else { |
| goto handle_unusual; |
| } |
| continue; |
| default: |
| goto handle_unusual; |
| } // switch |
| handle_unusual: |
| if ((tag == 0) || ((tag & 7) == 4)) { |
| CHK_(ptr); |
| ctx->SetLastTag(tag); |
| goto message_done; |
| } |
| ptr = UnknownFieldParse( |
| tag, |
| _internal_metadata_.mutable_unknown_fields<std::string>(), |
| ptr, ctx); |
| CHK_(ptr != nullptr); |
| } // while |
| message_done: |
| return ptr; |
| failure: |
| ptr = nullptr; |
| goto message_done; |
| #undef CHK_ |
| } |
| |
| ::uint8_t* MobileOperatorDB::_InternalSerialize( |
| ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { |
| // @@protoc_insertion_point(serialize_to_array_start:shill.mobile_operator_db.MobileOperatorDB) |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.MobileNetworkOperator mno = 1; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_mno_size()); i < n; i++) { |
| const auto& repfield = this->_internal_mno(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileVirtualNetworkOperator mvno = 3; |
| for (unsigned i = 0, |
| n = static_cast<unsigned>(this->_internal_mvno_size()); i < n; i++) { |
| const auto& repfield = this->_internal_mvno(i); |
| target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: |
| InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), |
| static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); |
| } |
| // @@protoc_insertion_point(serialize_to_array_end:shill.mobile_operator_db.MobileOperatorDB) |
| return target; |
| } |
| |
| ::size_t MobileOperatorDB::ByteSizeLong() const { |
| // @@protoc_insertion_point(message_byte_size_start:shill.mobile_operator_db.MobileOperatorDB) |
| ::size_t total_size = 0; |
| |
| ::uint32_t cached_has_bits = 0; |
| // Prevent compiler warnings about cached_has_bits being unused |
| (void) cached_has_bits; |
| |
| // repeated .shill.mobile_operator_db.MobileNetworkOperator mno = 1; |
| total_size += 1UL * this->_internal_mno_size(); |
| for (const auto& msg : this->_internal_mno()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| // repeated .shill.mobile_operator_db.MobileVirtualNetworkOperator mvno = 3; |
| total_size += 1UL * this->_internal_mvno_size(); |
| for (const auto& msg : this->_internal_mvno()) { |
| total_size += |
| ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); |
| } |
| |
| if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { |
| total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); |
| } |
| int cached_size = ::_pbi::ToCachedSize(total_size); |
| SetCachedSize(cached_size); |
| return total_size; |
| } |
| |
| void MobileOperatorDB::CheckTypeAndMergeFrom( |
| const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { |
| MergeFrom(*::_pbi::DownCast<const MobileOperatorDB*>( |
| &from)); |
| } |
| |
| void MobileOperatorDB::MergeFrom(const MobileOperatorDB& from) { |
| MobileOperatorDB* const _this = this; |
| // @@protoc_insertion_point(class_specific_merge_from_start:shill.mobile_operator_db.MobileOperatorDB) |
| ABSL_DCHECK_NE(&from, _this); |
| ::uint32_t cached_has_bits = 0; |
| (void) cached_has_bits; |
| |
| _this->_internal_mutable_mno()->MergeFrom(from._internal_mno()); |
| _this->_internal_mutable_mvno()->MergeFrom(from._internal_mvno()); |
| _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); |
| } |
| |
| void MobileOperatorDB::CopyFrom(const MobileOperatorDB& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:shill.mobile_operator_db.MobileOperatorDB) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool MobileOperatorDB::IsInitialized() const { |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_mno())) |
| return false; |
| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_internal_mvno())) |
| return false; |
| return true; |
| } |
| |
| void MobileOperatorDB::InternalSwap(MobileOperatorDB* other) { |
| using std::swap; |
| _internal_metadata_.InternalSwap(&other->_internal_metadata_); |
| _internal_mutable_mno()->InternalSwap(other->_internal_mutable_mno()); |
| _internal_mutable_mvno()->InternalSwap(other->_internal_mutable_mvno()); |
| } |
| |
| std::string MobileOperatorDB::GetTypeName() const { |
| return "shill.mobile_operator_db.MobileOperatorDB"; |
| } |
| |
| // @@protoc_insertion_point(namespace_scope) |
| } // namespace mobile_operator_db |
| } // namespace shill |
| PROTOBUF_NAMESPACE_OPEN |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::FilterRange* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::FilterRange >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::FilterRange >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::Filter* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::Filter >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::Filter >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::LocalizedName* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::LocalizedName >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::LocalizedName >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::MobileAPN* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::MobileAPN >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::MobileAPN >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::OnlinePortal* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::OnlinePortal >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::OnlinePortal >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::Data* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::Data >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::Data >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::MobileVirtualNetworkOperator* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::MobileVirtualNetworkOperator >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::MobileVirtualNetworkOperator >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::MobileNetworkOperator* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::MobileNetworkOperator >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::MobileNetworkOperator >(arena); |
| } |
| template<> PROTOBUF_NOINLINE ::shill::mobile_operator_db::MobileOperatorDB* |
| Arena::CreateMaybeMessage< ::shill::mobile_operator_db::MobileOperatorDB >(Arena* arena) { |
| return Arena::CreateMessageInternal< ::shill::mobile_operator_db::MobileOperatorDB >(arena); |
| } |
| PROTOBUF_NAMESPACE_CLOSE |
| // @@protoc_insertion_point(global_scope) |
| #include "google/protobuf/port_undef.inc" |
