Protocol Buffers - Google's data interchange format (grpc依赖) https://developers.google.com/protocol-buffers/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

314 lines
11 KiB

// Protocol Buffers - Google's data interchange format
// Copyright 2024 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#ifndef GOOGLE_PROTOBUF_HPB_EXTENSION_H__
#define GOOGLE_PROTOBUF_HPB_EXTENSION_H__
#include <cstdint>
#include <type_traits>
#include <vector>
#include "absl/base/attributes.h"
#include "absl/log/absl_log.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "google/protobuf/hpb/backend/upb/interop.h"
#include "google/protobuf/hpb/internal/message_lock.h"
#include "google/protobuf/hpb/internal/template_help.h"
#include "google/protobuf/hpb/ptr.h"
#include "google/protobuf/hpb/status.h"
#include "upb/mem/arena.hpp"
#include "upb/message/accessors.h"
#include "upb/message/array.h"
#include "upb/mini_table/extension.h"
#include "upb/mini_table/extension_registry.h"
namespace hpb {
class ExtensionRegistry;
namespace internal {
absl::Status MoveExtension(upb_Message* message, upb_Arena* message_arena,
const upb_MiniTableExtension* ext,
upb_Message* extension, upb_Arena* extension_arena);
absl::Status SetExtension(upb_Message* message, upb_Arena* message_arena,
const upb_MiniTableExtension* ext,
const upb_Message* extension);
/**
* Trait that maps upb extension types to the corresponding
* return value: ubp_MessageValue.
*
* All partial specializations must have:
* - DefaultType: the type of the default value.
* - ReturnType: the type of the return value.
* - kGetter: the corresponding upb_MessageValue upb_Message_GetExtension* func
*/
template <typename T, typename = void>
struct UpbExtensionTrait;
template <>
struct UpbExtensionTrait<int32_t> {
using DefaultType = int32_t;
using ReturnType = int32_t;
static constexpr auto kGetter = upb_Message_GetExtensionInt32;
static constexpr auto kSetter = upb_Message_SetExtensionInt32;
};
template <>
struct UpbExtensionTrait<int64_t> {
using DefaultType = int64_t;
using ReturnType = int64_t;
static constexpr auto kGetter = upb_Message_GetExtensionInt64;
static constexpr auto kSetter = upb_Message_SetExtensionInt64;
};
// TODO: b/375460289 - flesh out non-promotional msg support that does
// not return an error if missing but the default msg
template <typename T>
struct UpbExtensionTrait<T> {
using DefaultType = std::false_type;
using ReturnType = Ptr<const T>;
};
// -------------------------------------------------------------------
// ExtensionIdentifier
// This is the type of actual extension objects. E.g. if you have:
// extend Foo {
// optional MyExtension bar = 1234;
// }
// then "bar" will be defined in C++ as:
// ExtensionIdentifier<Foo, MyExtension> bar(&namespace_bar_ext);
template <typename ExtendeeType, typename ExtensionType>
class ExtensionIdentifier {
public:
using Extension = ExtensionType;
using Extendee = ExtendeeType;
// Placeholder for extant legacy callers, avoid use if possible
const upb_MiniTableExtension* mini_table_ext() const {
return mini_table_ext_;
}
private:
constexpr explicit ExtensionIdentifier(
const upb_MiniTableExtension* mte,
typename UpbExtensionTrait<ExtensionType>::DefaultType val)
: mini_table_ext_(mte), default_val_(val) {}
constexpr uint32_t number() const {
return upb_MiniTableExtension_Number(mini_table_ext_);
}
const upb_MiniTableExtension* mini_table_ext_;
typename UpbExtensionTrait<ExtensionType>::ReturnType default_value() const {
if constexpr (IsHpbClass<ExtensionType>) {
return ExtensionType::default_instance();
} else {
return default_val_;
}
}
typename UpbExtensionTrait<ExtensionType>::DefaultType default_val_;
friend struct PrivateAccess;
};
upb_ExtensionRegistry* GetUpbExtensions(
const ExtensionRegistry& extension_registry);
} // namespace internal
class ExtensionRegistry {
public:
ExtensionRegistry(
const std::vector<const upb_MiniTableExtension*>& extensions,
const upb::Arena& arena)
: registry_(upb_ExtensionRegistry_New(arena.ptr())) {
if (registry_) {
for (const auto extension : extensions) {
const auto* ext = extension;
bool success = upb_ExtensionRegistry_AddArray(registry_, &ext, 1);
if (!success) {
registry_ = nullptr;
break;
}
}
}
}
private:
friend upb_ExtensionRegistry* ::hpb::internal::GetUpbExtensions(
const ExtensionRegistry& extension_registry);
upb_ExtensionRegistry* registry_;
};
template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
ABSL_MUST_USE_RESULT bool HasExtension(
Ptr<T> message,
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
return ::hpb::internal::HasExtensionOrUnknown(
hpb::interop::upb::GetMessage(message), id.mini_table_ext());
}
template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
ABSL_MUST_USE_RESULT bool HasExtension(
const T* message,
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
return HasExtension(Ptr(message), id);
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>,
typename = hpb::internal::EnableIfMutableProto<T>>
void ClearExtension(
Ptr<T> message,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id) {
static_assert(!std::is_const_v<T>, "");
upb_Message_ClearExtension(hpb::interop::upb::GetMessage(message),
id.mini_table_ext());
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
void ClearExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id) {
ClearExtension(Ptr(message), id);
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>,
typename = hpb::internal::EnableIfMutableProto<T>>
absl::Status SetExtension(
Ptr<T> message,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
const Extension& value) {
if constexpr (std::is_integral_v<Extension>) {
bool res = hpb::internal::UpbExtensionTrait<Extension>::kSetter(
hpb::interop::upb::GetMessage(message), id.mini_table_ext(), value,
hpb::interop::upb::GetArena(message));
return res ? absl::OkStatus() : MessageAllocationError();
} else {
static_assert(!std::is_const_v<T>);
auto* message_arena = hpb::interop::upb::GetArena(message);
return ::hpb::internal::SetExtension(hpb::interop::upb::GetMessage(message),
message_arena, id.mini_table_ext(),
hpb::interop::upb::GetMessage(&value));
}
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>,
typename = hpb::internal::EnableIfMutableProto<T>>
absl::Status SetExtension(
Ptr<T> message,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Ptr<Extension> value) {
static_assert(!std::is_const_v<T>);
auto* message_arena = hpb::interop::upb::GetArena(message);
return ::hpb::internal::SetExtension(hpb::interop::upb::GetMessage(message),
message_arena, id.mini_table_ext(),
hpb::interop::upb::GetMessage(value));
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>,
typename = hpb::internal::EnableIfMutableProto<T>>
absl::Status SetExtension(
Ptr<T> message,
const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Extension&& value) {
if constexpr (std::is_integral_v<Extension>) {
bool res = hpb::internal::UpbExtensionTrait<Extension>::kSetter(
hpb::interop::upb::GetMessage(message), id.mini_table_ext(), value,
hpb::interop::upb::GetArena(message));
return res ? absl::OkStatus() : MessageAllocationError();
} else {
Extension ext = std::forward<Extension>(value);
static_assert(!std::is_const_v<T>);
auto* message_arena = hpb::interop::upb::GetArena(message);
auto* extension_arena = hpb::interop::upb::GetArena(&ext);
return ::hpb::internal::MoveExtension(
hpb::interop::upb::GetMessage(message), message_arena,
id.mini_table_ext(), hpb::interop::upb::GetMessage(&ext),
extension_arena);
}
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
absl::Status SetExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
const Extension& value) {
return ::hpb::SetExtension(Ptr(message), id, value);
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
absl::Status SetExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Extension&& value) {
return ::hpb::SetExtension(Ptr(message), id, std::forward<Extension>(value));
}
template <typename T, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
absl::Status SetExtension(
T* message, const ::hpb::internal::ExtensionIdentifier<T, Extension>& id,
Ptr<Extension> value) {
return ::hpb::SetExtension(Ptr(message), id, value);
}
template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
absl::StatusOr<typename internal::UpbExtensionTrait<Extension>::ReturnType>
GetExtension(
Ptr<T> message,
const ::hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
if constexpr (std::is_integral_v<Extension>) {
auto default_val = hpb::internal::PrivateAccess::GetDefaultValue(id);
absl::StatusOr<Extension> res =
hpb::internal::UpbExtensionTrait<Extension>::kGetter(
hpb::interop::upb::GetMessage(message), id.mini_table_ext(),
default_val);
return res;
} else {
upb_MessageValue value;
const bool ok = ::hpb::internal::GetOrPromoteExtension(
hpb::interop::upb::GetMessage(message), id.mini_table_ext(),
hpb::interop::upb::GetArena(message), &value);
if (!ok) {
return ExtensionNotFoundError(
upb_MiniTableExtension_Number(id.mini_table_ext()));
}
return Ptr<const Extension>(::hpb::interop::upb::MakeCHandle<Extension>(
(upb_Message*)value.msg_val, hpb::interop::upb::GetArena(message)));
}
}
template <typename T, typename Extendee, typename Extension,
typename = hpb::internal::EnableIfHpbClassThatHasExtensions<T>>
absl::StatusOr<typename internal::UpbExtensionTrait<Extension>::ReturnType>
GetExtension(
const T* message,
const hpb::internal::ExtensionIdentifier<Extendee, Extension>& id) {
return GetExtension(Ptr(message), id);
}
template <typename T, typename Extension>
constexpr uint32_t ExtensionNumber(
const internal::ExtensionIdentifier<T, Extension>& id) {
return internal::PrivateAccess::GetExtensionNumber(id);
}
} // namespace hpb
#endif // GOOGLE_PROTOBUF_HPB_EXTENSION_H__