google/protobuf/descriptor_visitor.h

0001 // Protocol Buffers - Google's data interchange format
0002 // Copyright 2023 Google Inc.  All rights reserved.
0003 //
0004 // Use of this source code is governed by a BSD-style
0005 // license that can be found in the LICENSE file or at
0006 // https://developers.google.com/open-source/licenses/bsd
0007
0008 #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_VISITOR_H__
0009 #define GOOGLE_PROTOBUF_DESCRIPTOR_VISITOR_H__
0010
0011 #include "google/protobuf/descriptor.h"
0012 #include "google/protobuf/descriptor.pb.h"
0013 #include "google/protobuf/generated_message_reflection.h"
0014
0015 namespace google {
0016 namespace protobuf {
0017 namespace internal {
0018
0019 // Visit every node in the descriptors calling `visitor(node, proto)`.
0020 // The visitor does not need to handle all possible node types. Types that are
0021 // not visitable via `visitor` will be ignored.
0022 template <typename Visitor>
0023 void VisitDescriptors(const FileDescriptor& file,
0024                       const FileDescriptorProto& proto, Visitor visitor);
0025
0026 template <typename Visitor>
0027 void VisitDescriptors(const FileDescriptor& file, FileDescriptorProto& proto,
0028                       Visitor visitor);
0029
0030 // Visit just the descriptors, without a corresponding proto tree.
0031 template <typename Visitor>
0032 void VisitDescriptors(const FileDescriptor& file, Visitor visitor);
0033
0034 template <typename Visitor>
0035 struct VisitImpl {
0036   Visitor visitor;
0037   template <typename... Proto>
0038   void Visit(const FieldDescriptor& descriptor, Proto&... proto) {
0039     visitor(descriptor, proto...);
0040   }
0041
0042   template <typename... Proto>
0043   void Visit(const EnumValueDescriptor& descriptor, Proto&... proto) {
0044     visitor(descriptor, proto...);
0045   }
0046
0047   template <typename... Proto>
0048   void Visit(const EnumDescriptor& descriptor, Proto&... proto) {
0049     visitor(descriptor, proto...);
0050     for (int i = 0; i < descriptor.value_count(); i++) {
0051       Visit(*descriptor.value(i), value(proto, i)...);
0052     }
0053   }
0054
0055   template <typename... Proto>
0056   void Visit(const Descriptor::ExtensionRange& descriptor, Proto&... proto) {
0057     visitor(descriptor, proto...);
0058   }
0059
0060   template <typename... Proto>
0061   void Visit(const OneofDescriptor& descriptor, Proto&... proto) {
0062     visitor(descriptor, proto...);
0063   }
0064
0065   template <typename... Proto>
0066   void Visit(const Descriptor& descriptor, Proto&... proto) {
0067     visitor(descriptor, proto...);
0068
0069     for (int i = 0; i < descriptor.enum_type_count(); i++) {
0070       Visit(*descriptor.enum_type(i), enum_type(proto, i)...);
0071     }
0072
0073     for (int i = 0; i < descriptor.oneof_decl_count(); i++) {
0074       Visit(*descriptor.oneof_decl(i), oneof_decl(proto, i)...);
0075     }
0076
0077     for (int i = 0; i < descriptor.field_count(); i++) {
0078       Visit(*descriptor.field(i), field(proto, i)...);
0079     }
0080
0081     for (int i = 0; i < descriptor.nested_type_count(); i++) {
0082       Visit(*descriptor.nested_type(i), nested_type(proto, i)...);
0083     }
0084
0085     for (int i = 0; i < descriptor.extension_count(); i++) {
0086       Visit(*descriptor.extension(i), extension(proto, i)...);
0087     }
0088
0089     for (int i = 0; i < descriptor.extension_range_count(); i++) {
0090       Visit(*descriptor.extension_range(i), extension_range(proto, i)...);
0091     }
0092   }
0093
0094   template <typename... Proto>
0095   void Visit(const MethodDescriptor& method, Proto&... proto) {
0096     visitor(method, proto...);
0097   }
0098
0099   template <typename... Proto>
0100   void Visit(const ServiceDescriptor& descriptor, Proto&... proto) {
0101     visitor(descriptor, proto...);
0102     for (int i = 0; i < descriptor.method_count(); i++) {
0103       Visit(*descriptor.method(i), method(proto, i)...);
0104     }
0105   }
0106
0107   template <typename... Proto>
0108   void Visit(const FileDescriptor& descriptor, Proto&... proto) {
0109     visitor(descriptor, proto...);
0110     for (int i = 0; i < descriptor.message_type_count(); i++) {
0111       Visit(*descriptor.message_type(i), message_type(proto, i)...);
0112     }
0113     for (int i = 0; i < descriptor.enum_type_count(); i++) {
0114       Visit(*descriptor.enum_type(i), enum_type(proto, i)...);
0115     }
0116     for (int i = 0; i < descriptor.extension_count(); i++) {
0117       Visit(*descriptor.extension(i), extension(proto, i)...);
0118     }
0119     for (int i = 0; i < descriptor.service_count(); i++) {
0120       Visit(*descriptor.service(i), service(proto, i)...);
0121     }
0122   }
0123
0124  private:
0125 #define CREATE_NESTED_GETTER(TYPE, NESTED)                                     \
0126   inline auto& NESTED(TYPE& desc, int i) { return *desc.mutable_##NESTED(i); } \
0127   inline auto& NESTED(const TYPE& desc, int i) { return desc.NESTED(i); }
0128
0129   CREATE_NESTED_GETTER(DescriptorProto, enum_type);
0130   CREATE_NESTED_GETTER(DescriptorProto, extension);
0131   CREATE_NESTED_GETTER(DescriptorProto, extension_range);
0132   CREATE_NESTED_GETTER(DescriptorProto, field);
0133   CREATE_NESTED_GETTER(DescriptorProto, nested_type);
0134   CREATE_NESTED_GETTER(DescriptorProto, oneof_decl);
0135   CREATE_NESTED_GETTER(EnumDescriptorProto, value);
0136   CREATE_NESTED_GETTER(FileDescriptorProto, enum_type);
0137   CREATE_NESTED_GETTER(FileDescriptorProto, extension);
0138   CREATE_NESTED_GETTER(FileDescriptorProto, message_type);
0139   CREATE_NESTED_GETTER(FileDescriptorProto, service);
0140   CREATE_NESTED_GETTER(ServiceDescriptorProto, method);
0141
0142 #undef CREATE_NESTED_GETTER
0143 };
0144
0145 // Provide a fallback to ignore all the nodes that are not interesting to the
0146 // input visitor.
0147 template <typename Visitor>
0148 struct VisitorImpl : Visitor {
0149   explicit VisitorImpl(Visitor visitor) : Visitor(visitor) {}
0150
0151   // Pull in all of the supplied callbacks.
0152   using Visitor::operator();
0153
0154   // Honeypots to ignore all inputs that Visitor does not take.
0155   struct DescriptorEater {
0156     template <typename T>
0157     DescriptorEater(T&&) {}  // NOLINT
0158   };
0159   void operator()(DescriptorEater, DescriptorEater) const {}
0160   void operator()(DescriptorEater) const {}
0161 };
0162
0163 template <typename Visitor>
0164 void VisitDescriptors(const FileDescriptor& file,
0165                       const FileDescriptorProto& proto, Visitor visitor) {
0166   using VisitorImpl = internal::VisitorImpl<Visitor>;
0167   internal::VisitImpl<VisitorImpl>{VisitorImpl(visitor)}.Visit(file, proto);
0168 }
0169
0170 template <typename Visitor>
0171 void VisitDescriptors(const FileDescriptor& file, FileDescriptorProto& proto,
0172                       Visitor visitor) {
0173   using VisitorImpl = internal::VisitorImpl<Visitor>;
0174   internal::VisitImpl<VisitorImpl>{VisitorImpl(visitor)}.Visit(file, proto);
0175 }
0176
0177 template <typename Visitor>
0178 void VisitDescriptors(const FileDescriptor& file, Visitor visitor) {
0179   using VisitorImpl = internal::VisitorImpl<Visitor>;
0180   internal::VisitImpl<VisitorImpl>{VisitorImpl(visitor)}.Visit(file);
0181 }
0182
0183 }  // namespace internal
0184 }  // namespace protobuf
0185 }  // namespace google
0186
0187 #endif  // GOOGLE_PROTOBUF_DESCRIPTOR_VISITOR_H__