grpc 1.54.2 → 1.55.3

data/third_party/upb/upb/def.hpp

@@ -23,419 +23,11 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// This header is deprecated, use upb/reflection/def.hpp instead
+
 #ifndef UPB_DEF_HPP_
 #define UPB_DEF_HPP_
 
-#include <cstring>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "upb/def.h"
-#include "upb/reflection.h"
-#include "upb/upb.hpp"
-
-namespace upb {
-
-typedef upb_MessageValue MessageValue;
-
-class EnumDefPtr;
-class FileDefPtr;
-class MessageDefPtr;
-class OneofDefPtr;
-
-// A upb::FieldDefPtr describes a single field in a message.  It is most often
-// found as a part of a upb_MessageDef, but can also stand alone to represent
-// an extension.
-class FieldDefPtr {
- public:
-  FieldDefPtr() : ptr_(nullptr) {}
-  explicit FieldDefPtr(const upb_FieldDef* ptr) : ptr_(ptr) {}
-
-  const upb_FieldDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  typedef upb_CType Type;
-  typedef upb_Label Label;
-  typedef upb_FieldType DescriptorType;
-
-  const char* full_name() const { return upb_FieldDef_FullName(ptr_); }
-
-  Type type() const { return upb_FieldDef_CType(ptr_); }
-  Label label() const { return upb_FieldDef_Label(ptr_); }
-  const char* name() const { return upb_FieldDef_Name(ptr_); }
-  const char* json_name() const { return upb_FieldDef_JsonName(ptr_); }
-  uint32_t number() const { return upb_FieldDef_Number(ptr_); }
-  bool is_extension() const { return upb_FieldDef_IsExtension(ptr_); }
-
-  // For non-string, non-submessage fields, this indicates whether binary
-  // protobufs are encoded in packed or non-packed format.
-  //
-  // Note: this accessor reflects the fact that "packed" has different defaults
-  // depending on whether the proto is proto2 or proto3.
-  bool packed() const { return upb_FieldDef_IsPacked(ptr_); }
-
-  // An integer that can be used as an index into an array of fields for
-  // whatever message this field belongs to.  Guaranteed to be less than
-  // f->containing_type()->field_count().  May only be accessed once the def has
-  // been finalized.
-  uint32_t index() const { return upb_FieldDef_Index(ptr_); }
-
-  // The MessageDef to which this field belongs.
-  //
-  // If this field has been added to a MessageDef, that message can be retrieved
-  // directly (this is always the case for frozen FieldDefs).
-  //
-  // If the field has not yet been added to a MessageDef, you can set the name
-  // of the containing type symbolically instead.  This is mostly useful for
-  // extensions, where the extension is declared separately from the message.
-  MessageDefPtr containing_type() const;
-
-  // The OneofDef to which this field belongs, or NULL if this field is not part
-  // of a oneof.
-  OneofDefPtr containing_oneof() const;
-
-  // The field's type according to the enum in descriptor.proto.  This is not
-  // the same as UPB_TYPE_*, because it distinguishes between (for example)
-  // INT32 and SINT32, whereas our "type" enum does not.  This return of
-  // descriptor_type() is a function of type(), integer_format(), and
-  // is_tag_delimited().
-  DescriptorType descriptor_type() const { return upb_FieldDef_Type(ptr_); }
-
-  // Convenient field type tests.
-  bool IsSubMessage() const { return upb_FieldDef_IsSubMessage(ptr_); }
-  bool IsString() const { return upb_FieldDef_IsString(ptr_); }
-  bool IsSequence() const { return upb_FieldDef_IsRepeated(ptr_); }
-  bool IsPrimitive() const { return upb_FieldDef_IsPrimitive(ptr_); }
-  bool IsMap() const { return upb_FieldDef_IsMap(ptr_); }
-
-  MessageValue default_value() const { return upb_FieldDef_Default(ptr_); }
-
-  // Returns the enum or submessage def for this field, if any.  The field's
-  // type must match (ie. you may only call enum_subdef() for fields where
-  // type() == kUpb_CType_Enum).
-  EnumDefPtr enum_subdef() const;
-  MessageDefPtr message_subdef() const;
-
- private:
-  const upb_FieldDef* ptr_;
-};
-
-// Class that represents a oneof.
-class OneofDefPtr {
- public:
-  OneofDefPtr() : ptr_(nullptr) {}
-  explicit OneofDefPtr(const upb_OneofDef* ptr) : ptr_(ptr) {}
-
-  const upb_OneofDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  // Returns the MessageDef that contains this OneofDef.
-  MessageDefPtr containing_type() const;
-
-  // Returns the name of this oneof.
-  const char* name() const { return upb_OneofDef_Name(ptr_); }
-
-  // Returns the number of fields in the oneof.
-  int field_count() const { return upb_OneofDef_FieldCount(ptr_); }
-  FieldDefPtr field(int i) const {
-    return FieldDefPtr(upb_OneofDef_Field(ptr_, i));
-  }
-
-  // Looks up by name.
-  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
-    return FieldDefPtr(upb_OneofDef_LookupNameWithSize(ptr_, name, len));
-  }
-  FieldDefPtr FindFieldByName(const char* name) const {
-    return FieldDefPtr(upb_OneofDef_LookupName(ptr_, name));
-  }
-
-  template <class T>
-  FieldDefPtr FindFieldByName(const T& str) const {
-    return FindFieldByName(str.c_str(), str.size());
-  }
-
-  // Looks up by tag number.
-  FieldDefPtr FindFieldByNumber(uint32_t num) const {
-    return FieldDefPtr(upb_OneofDef_LookupNumber(ptr_, num));
-  }
-
- private:
-  const upb_OneofDef* ptr_;
-};
-
-// Structure that describes a single .proto message type.
-class MessageDefPtr {
- public:
-  MessageDefPtr() : ptr_(nullptr) {}
-  explicit MessageDefPtr(const upb_MessageDef* ptr) : ptr_(ptr) {}
-
-  const upb_MessageDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  FileDefPtr file() const;
-
-  const char* full_name() const { return upb_MessageDef_FullName(ptr_); }
-  const char* name() const { return upb_MessageDef_Name(ptr_); }
-
-  // The number of fields that belong to the MessageDef.
-  int field_count() const { return upb_MessageDef_FieldCount(ptr_); }
-  FieldDefPtr field(int i) const {
-    return FieldDefPtr(upb_MessageDef_Field(ptr_, i));
-  }
-
-  // The number of oneofs that belong to the MessageDef.
-  int oneof_count() const { return upb_MessageDef_OneofCount(ptr_); }
-  OneofDefPtr oneof(int i) const {
-    return OneofDefPtr(upb_MessageDef_Oneof(ptr_, i));
-  }
-
-  upb_Syntax syntax() const { return upb_MessageDef_Syntax(ptr_); }
-
-  // These return null pointers if the field is not found.
-  FieldDefPtr FindFieldByNumber(uint32_t number) const {
-    return FieldDefPtr(upb_MessageDef_FindFieldByNumber(ptr_, number));
-  }
-  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
-    return FieldDefPtr(upb_MessageDef_FindFieldByNameWithSize(ptr_, name, len));
-  }
-  FieldDefPtr FindFieldByName(const char* name) const {
-    return FieldDefPtr(upb_MessageDef_FindFieldByName(ptr_, name));
-  }
-
-  template <class T>
-  FieldDefPtr FindFieldByName(const T& str) const {
-    return FindFieldByName(str.c_str(), str.size());
-  }
-
-  OneofDefPtr FindOneofByName(const char* name, size_t len) const {
-    return OneofDefPtr(upb_MessageDef_FindOneofByNameWithSize(ptr_, name, len));
-  }
-
-  OneofDefPtr FindOneofByName(const char* name) const {
-    return OneofDefPtr(upb_MessageDef_FindOneofByName(ptr_, name));
-  }
-
-  template <class T>
-  OneofDefPtr FindOneofByName(const T& str) const {
-    return FindOneofByName(str.c_str(), str.size());
-  }
-
-  // Is this message a map entry?
-  bool mapentry() const { return upb_MessageDef_IsMapEntry(ptr_); }
-
-  // Return the type of well known type message. kUpb_WellKnown_Unspecified for
-  // non-well-known message.
-  upb_WellKnown wellknowntype() const {
-    return upb_MessageDef_WellKnownType(ptr_);
-  }
-
- private:
-  class FieldIter {
-   public:
-    explicit FieldIter(const upb_MessageDef* m, int i) : m_(m), i_(i) {}
-    void operator++() { i_++; }
-
-    FieldDefPtr operator*() {
-      return FieldDefPtr(upb_MessageDef_Field(m_, i_));
-    }
-    bool operator!=(const FieldIter& other) { return i_ != other.i_; }
-    bool operator==(const FieldIter& other) { return i_ == other.i_; }
-
-   private:
-    const upb_MessageDef* m_;
-    int i_;
-  };
-
-  class FieldAccessor {
-   public:
-    explicit FieldAccessor(const upb_MessageDef* md) : md_(md) {}
-    FieldIter begin() { return FieldIter(md_, 0); }
-    FieldIter end() { return FieldIter(md_, upb_MessageDef_FieldCount(md_)); }
-
-   private:
-    const upb_MessageDef* md_;
-  };
-
-  class OneofIter {
-   public:
-    explicit OneofIter(const upb_MessageDef* m, int i) : m_(m), i_(i) {}
-    void operator++() { i_++; }
-
-    OneofDefPtr operator*() {
-      return OneofDefPtr(upb_MessageDef_Oneof(m_, i_));
-    }
-    bool operator!=(const OneofIter& other) { return i_ != other.i_; }
-    bool operator==(const OneofIter& other) { return i_ == other.i_; }
-
-   private:
-    const upb_MessageDef* m_;
-    int i_;
-  };
-
-  class OneofAccessor {
-   public:
-    explicit OneofAccessor(const upb_MessageDef* md) : md_(md) {}
-    OneofIter begin() { return OneofIter(md_, 0); }
-    OneofIter end() { return OneofIter(md_, upb_MessageDef_OneofCount(md_)); }
-
-   private:
-    const upb_MessageDef* md_;
-  };
-
- public:
-  FieldAccessor fields() const { return FieldAccessor(ptr()); }
-  OneofAccessor oneofs() const { return OneofAccessor(ptr()); }
-
- private:
-  const upb_MessageDef* ptr_;
-};
-
-class EnumValDefPtr {
- public:
-  EnumValDefPtr() : ptr_(nullptr) {}
-  explicit EnumValDefPtr(const upb_EnumValueDef* ptr) : ptr_(ptr) {}
-
-  int32_t number() const { return upb_EnumValueDef_Number(ptr_); }
-  const char* full_name() const { return upb_EnumValueDef_FullName(ptr_); }
-  const char* name() const { return upb_EnumValueDef_Name(ptr_); }
-
- private:
-  const upb_EnumValueDef* ptr_;
-};
-
-class EnumDefPtr {
- public:
-  EnumDefPtr() : ptr_(nullptr) {}
-  explicit EnumDefPtr(const upb_EnumDef* ptr) : ptr_(ptr) {}
-
-  const upb_EnumDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  const char* full_name() const { return upb_EnumDef_FullName(ptr_); }
-  const char* name() const { return upb_EnumDef_Name(ptr_); }
-
-  // The value that is used as the default when no field default is specified.
-  // If not set explicitly, the first value that was added will be used.
-  // The default value must be a member of the enum.
-  // Requires that value_count() > 0.
-  int32_t default_value() const { return upb_EnumDef_Default(ptr_); }
-
-  // Returns the number of values currently defined in the enum.  Note that
-  // multiple names can refer to the same number, so this may be greater than
-  // the total number of unique numbers.
-  int value_count() const { return upb_EnumDef_ValueCount(ptr_); }
-
-  // Lookups from name to integer, returning true if found.
-  EnumValDefPtr FindValueByName(const char* name) const {
-    return EnumValDefPtr(upb_EnumDef_FindValueByName(ptr_, name));
-  }
-
-  // Finds the name corresponding to the given number, or NULL if none was
-  // found.  If more than one name corresponds to this number, returns the
-  // first one that was added.
-  EnumValDefPtr FindValueByNumber(int32_t num) const {
-    return EnumValDefPtr(upb_EnumDef_FindValueByNumber(ptr_, num));
-  }
-
- private:
-  const upb_EnumDef* ptr_;
-};
-
-// Class that represents a .proto file with some things defined in it.
-//
-// Many users won't care about FileDefs, but they are necessary if you want to
-// read the values of file-level options.
-class FileDefPtr {
- public:
-  explicit FileDefPtr(const upb_FileDef* ptr) : ptr_(ptr) {}
-
-  const upb_FileDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  // Get/set name of the file (eg. "foo/bar.proto").
-  const char* name() const { return upb_FileDef_Name(ptr_); }
-
-  // Package name for definitions inside the file (eg. "foo.bar").
-  const char* package() const { return upb_FileDef_Package(ptr_); }
-
-  // Syntax for the file.  Defaults to proto2.
-  upb_Syntax syntax() const { return upb_FileDef_Syntax(ptr_); }
-
-  // Get the list of dependencies from the file.  These are returned in the
-  // order that they were added to the FileDefPtr.
-  int dependency_count() const { return upb_FileDef_DependencyCount(ptr_); }
-  const FileDefPtr dependency(int index) const {
-    return FileDefPtr(upb_FileDef_Dependency(ptr_, index));
-  }
-
- private:
-  const upb_FileDef* ptr_;
-};
-
-// Non-const methods in upb::DefPool are NOT thread-safe.
-class DefPool {
- public:
-  DefPool() : ptr_(upb_DefPool_New(), upb_DefPool_Free) {}
-  explicit DefPool(upb_DefPool* s) : ptr_(s, upb_DefPool_Free) {}
-
-  const upb_DefPool* ptr() const { return ptr_.get(); }
-  upb_DefPool* ptr() { return ptr_.get(); }
-
-  // Finds an entry in the symbol table with this exact name.  If not found,
-  // returns NULL.
-  MessageDefPtr FindMessageByName(const char* sym) const {
-    return MessageDefPtr(upb_DefPool_FindMessageByName(ptr_.get(), sym));
-  }
-
-  EnumDefPtr FindEnumByName(const char* sym) const {
-    return EnumDefPtr(upb_DefPool_FindEnumByName(ptr_.get(), sym));
-  }
-
-  FileDefPtr FindFileByName(const char* name) const {
-    return FileDefPtr(upb_DefPool_FindFileByName(ptr_.get(), name));
-  }
-
-  // TODO: iteration?
-
-  // Adds the given serialized FileDescriptorProto to the pool.
-  FileDefPtr AddFile(const google_protobuf_FileDescriptorProto* file_proto,
-                     Status* status) {
-    return FileDefPtr(
-        upb_DefPool_AddFile(ptr_.get(), file_proto, status->ptr()));
-  }
-
- private:
-  std::unique_ptr<upb_DefPool, decltype(&upb_DefPool_Free)> ptr_;
-};
-
-// TODO(b/236632406): This typedef is deprecated. Delete it.
-using SymbolTable = DefPool;
-
-inline FileDefPtr MessageDefPtr::file() const {
-  return FileDefPtr(upb_MessageDef_File(ptr_));
-}
-
-inline MessageDefPtr FieldDefPtr::message_subdef() const {
-  return MessageDefPtr(upb_FieldDef_MessageSubDef(ptr_));
-}
-
-inline MessageDefPtr FieldDefPtr::containing_type() const {
-  return MessageDefPtr(upb_FieldDef_ContainingType(ptr_));
-}
-
-inline MessageDefPtr OneofDefPtr::containing_type() const {
-  return MessageDefPtr(upb_OneofDef_ContainingType(ptr_));
-}
-
-inline OneofDefPtr FieldDefPtr::containing_oneof() const {
-  return OneofDefPtr(upb_FieldDef_ContainingOneof(ptr_));
-}
-
-inline EnumDefPtr FieldDefPtr::enum_subdef() const {
-  return EnumDefPtr(upb_FieldDef_EnumSubDef(ptr_));
-}
-
-}  // namespace upb
+#include "upb/reflection/def.hpp"
 
 #endif  // UPB_DEF_HPP_

data/third_party/upb/upb/encode.h

@@ -25,57 +25,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * upb_Encode: parsing from a upb_Message using a upb_MiniTable.
- */
+// This header is deprecated, use upb/wire/encode.h instead
+// IWYU pragma: private, include "upb/wire/encode.h"
 
 #ifndef UPB_ENCODE_H_
 #define UPB_ENCODE_H_
 
-#include "upb/msg.h"
-
-/* Must be last. */
-#include "upb/port_def.inc"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum {
-  /* If set, the results of serializing will be deterministic across all
-   * instances of this binary. There are no guarantees across different
-   * binary builds.
-   *
-   * If your proto contains maps, the encoder will need to malloc()/free()
-   * memory during encode. */
-  kUpb_EncodeOption_Deterministic = 1,
-
-  /* When set, unknown fields are not printed. */
-  kUpb_EncodeOption_SkipUnknown = 2,
-
-  /* When set, the encode will fail if any required fields are missing. */
-  kUpb_EncodeOption_CheckRequired = 4,
-};
-
-#define UPB_ENCODE_MAXDEPTH(depth) ((depth) << 16)
-
-typedef enum {
-  kUpb_EncodeStatus_Ok = 0,
-  kUpb_EncodeStatus_OutOfMemory = 1,       // Arena alloc failed
-  kUpb_EncodeStatus_MaxDepthExceeded = 2,  // Exceeded UPB_ENCODE_MAXDEPTH
-
-  // kUpb_EncodeOption_CheckRequired failed but the parse otherwise succeeded.
-  kUpb_EncodeStatus_MissingRequired = 3,
-} upb_EncodeStatus;
-
-upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
-                            int options, upb_Arena* arena, char** buf,
-                            size_t* size);
-
-#include "upb/port_undef.inc"
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
+#include "upb/wire/encode.h"
 
 #endif /* UPB_ENCODE_H_ */

data/third_party/upb/upb/extension_registry.h

@@ -25,60 +25,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+// This header is deprecated, use upb/mini_table/extension_registry.h instead
+
 #ifndef UPB_EXTENSION_REGISTRY_H_
 #define UPB_EXTENSION_REGISTRY_H_
 
-#include <stddef.h>
-
-#include "upb/upb.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Extension registry: a dynamic data structure that stores a map of:
- *   (upb_MiniTable, number) -> extension info
- *
- * upb_decode() uses upb_ExtensionRegistry to look up extensions while parsing
- * binary format.
- *
- * upb_ExtensionRegistry is part of the mini-table (msglayout) family of
- * objects. Like all mini-table objects, it is suitable for reflection-less
- * builds that do not want to expose names into the binary.
- *
- * Unlike most mini-table types, upb_ExtensionRegistry requires dynamic memory
- * allocation and dynamic initialization:
- * * If reflection is being used, then upb_DefPool will construct an appropriate
- *   upb_ExtensionRegistry automatically.
- * * For a mini-table only build, the user must manually construct the
- *   upb_ExtensionRegistry and populate it with all of the extensions the user
- * cares about.
- * * A third alternative is to manually unpack relevant extensions after the
- *   main parse is complete, similar to how Any works. This is perhaps the
- *   nicest solution from the perspective of reducing dependencies, avoiding
- *   dynamic memory allocation, and avoiding the need to parse uninteresting
- *   extensions.  The downsides are:
- *     (1) parse errors are not caught during the main parse
- *     (2) the CPU hit of parsing comes during access, which could cause an
- *         undesirable stutter in application performance.
- *
- * Users cannot directly get or put into this map. Users can only add the
- * extensions from a generated module and pass the extension registry to the
- * binary decoder.
- *
- * A upb_DefPool provides a upb_ExtensionRegistry, so any users who use
- * reflection do not need to populate a upb_ExtensionRegistry directly.
- */
-
-struct upb_ExtensionRegistry;
-typedef struct upb_ExtensionRegistry upb_ExtensionRegistry;
-
-/* Creates a upb_ExtensionRegistry in the given arena.  The arena must outlive
- * any use of the extreg. */
-upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
+#include "upb/mini_table/extension_registry.h"
 
 #endif /* UPB_EXTENSION_REGISTRY_H_ */