Java DescriptorProtos.FileDescriptorProto方法代码示例

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private static DescriptorProtos.FileDescriptorProto getFileDescProtoForMsgType(
    String packageName,
    String messageType,
    DescriptorProtos.FileDescriptorSet set
) {
  DescriptorProtos.FileDescriptorProto file = null;
  for (DescriptorProtos.FileDescriptorProto fileDescriptorProto : set.getFileList()) {
    if (!packageMatch(fileDescriptorProto, packageName)) {
      continue;
    }
    file = containsMessageType(fileDescriptorProto, messageType);
    if (file != null) {
      break;
    }
  }
  return file;
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
/**
 * Returns an instance of {@link ProtoTypeMap} based on the given FileDescriptorProto instances.
 *
 * @param fileDescriptorProtos the full collection of files descriptors from the code generator request
 */
public static ProtoTypeMap of(@Nonnull Collection<DescriptorProtos.FileDescriptorProto> fileDescriptorProtos) {
    Preconditions.checkNotNull(fileDescriptorProtos, "fileDescriptorProtos");
    Preconditions.checkArgument(!fileDescriptorProtos.isEmpty(), "fileDescriptorProtos.isEmpty()");

    final ImmutableMap.Builder<String, String> types = ImmutableMap.builder();

    for (final DescriptorProtos.FileDescriptorProto fileDescriptor : fileDescriptorProtos) {
        final DescriptorProtos.FileOptions fileOptions = fileDescriptor.getOptions();

        final String protoPackage = fileDescriptor.hasPackage() ? "." + fileDescriptor.getPackage() : "";
        final String javaPackage = Strings.emptyToNull(
                fileOptions.hasJavaPackage() ?
                        fileOptions.getJavaPackage() :
                        fileDescriptor.getPackage());
        final String enclosingClassName =
                fileOptions.getJavaMultipleFiles() ?
                        null :
                        getJavaOuterClassname(fileDescriptor, fileOptions);



        fileDescriptor.getEnumTypeList().forEach(
            e -> types.put(
                    protoPackage + "." + e.getName(),
                    toJavaTypeName(e.getName(), enclosingClassName, javaPackage)));

        fileDescriptor.getMessageTypeList().forEach(
            m -> types.put(
                    protoPackage + "." + m.getName(),
                    toJavaTypeName(m.getName(), enclosingClassName, javaPackage)));
    }

    return new ProtoTypeMap(types.build());
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private static String getJavaOuterClassname(
        DescriptorProtos.FileDescriptorProto fileDescriptor,
        DescriptorProtos.FileOptions fileOptions) {

    if (fileOptions.hasJavaOuterClassname()) {
        return fileOptions.getJavaOuterClassname();
    }

    // If the outer class name is not explicitly defined, then we take the proto filename, strip its extension,
    // and convert it from snake case to camel case.
    String filename = fileDescriptor.getName().substring(0, fileDescriptor.getName().length() - ".proto".length());
    filename = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, filename);
    return appendOuterClassSuffix(filename, fileDescriptor);
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
/**
 * In the event of a name conflict between the outer and inner type names, protoc adds an OuterClass suffix to the
 * outer type's name.
 */
private static String appendOuterClassSuffix(final String enclosingClassName, DescriptorProtos.FileDescriptorProto fd) {
    if (fd.getEnumTypeList().stream().anyMatch(enumProto -> enumProto.getName().equals(enclosingClassName)) ||
        fd.getMessageTypeList().stream().anyMatch(messageProto -> messageProto.getName().equals(enclosingClassName))) {
        return enclosingClassName + "OuterClass";
    } else {
        return enclosingClassName;
    }
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private Stream<Context> extractContext(ProtoTypeMap protoTypeMap, DescriptorProtos.FileDescriptorProto proto) {
    return proto.getServiceList().stream()
            .map(s -> extractServiceContext(protoTypeMap, s))
            .map(ctx -> {
                ctx.packageName = extractPackageName(proto); return ctx;
            })
            .map(ctx -> {
                ctx.protoName = proto.getName(); return ctx;
            });
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private String extractPackageName(DescriptorProtos.FileDescriptorProto proto) {
    DescriptorProtos.FileOptions options = proto.getOptions();
    if (options != null) {
        String javaPackage = options.getJavaPackage();
        if (!Strings.isNullOrEmpty(javaPackage)) {
            return javaPackage;
        }
    }

    return Strings.nullToEmpty(proto.getPackage());
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
/**
 * Loads a Protobuf file descriptor set into an ubermap of file descriptors.
 *
 * @param set               FileDescriptorSet
 * @param dependenciesMap   FileDescriptor dependency map
 * @param fileDescriptorMap The populated map of FileDescriptors
 * @throws StageException
 */
public static void getAllFileDescriptors(
    DescriptorProtos.FileDescriptorSet set,
    Map<String, Set<Descriptors.FileDescriptor>> dependenciesMap,
    Map<String, Descriptors.FileDescriptor> fileDescriptorMap
) throws StageException {
  List<DescriptorProtos.FileDescriptorProto> fileList = set.getFileList();
  try {
    for (DescriptorProtos.FileDescriptorProto fdp : fileList) {
      if (!fileDescriptorMap.containsKey(fdp.getName())) {
        Set<Descriptors.FileDescriptor> dependencies = dependenciesMap.get(fdp.getName());
        if (dependencies == null) {
          dependencies = new LinkedHashSet<>();
          dependenciesMap.put(fdp.getName(), dependencies);
          dependencies.addAll(getDependencies(dependenciesMap, fileDescriptorMap, fdp, set));
        }
        Descriptors.FileDescriptor fileDescriptor = Descriptors.FileDescriptor.buildFrom(
            fdp,
            dependencies.toArray(new Descriptors.FileDescriptor[dependencies.size()])
        );
        fileDescriptorMap.put(fdp.getName(), fileDescriptor);
      }
    }
  } catch (Descriptors.DescriptorValidationException e) {
    throw new StageException(Errors.PROTOBUF_07, e.getDescription(), e);
  }
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
/**
 * Generates a protobuf descriptor instance from a FileDescriptor set.
 *
 * @param set               set of file descriptors
 * @param fileDescriptorMap map of message types to file descriptors
 * @param descriptorFile    descriptor file for message to be decoded
 * @param qualifiedMessageType       the name of the message to be decoded
 * @return protobuf descriptor instance
 * @throws StageException
 */
public static Descriptors.Descriptor getDescriptor(
    DescriptorProtos.FileDescriptorSet set,
    Map<String, Descriptors.FileDescriptor> fileDescriptorMap,
    String descriptorFile,
    String qualifiedMessageType
) throws StageException {

  // find the FileDescriptorProto which contains the message type
  // IF cannot find, then bail out
  String packageName = null;
  String messageType = qualifiedMessageType;
  int lastIndex = qualifiedMessageType.lastIndexOf('.');
  if (lastIndex != -1) {
    packageName = qualifiedMessageType.substring(0, lastIndex);
    messageType = qualifiedMessageType.substring(lastIndex + 1);
  }
  DescriptorProtos.FileDescriptorProto file = getFileDescProtoForMsgType(packageName, messageType, set);
  if (file == null) {
    // could not find the message type from all the proto files contained in the descriptor file
    throw new StageException(Errors.PROTOBUF_00, qualifiedMessageType, descriptorFile);
  }
  // finally get the FileDescriptor for the message type
  Descriptors.FileDescriptor fileDescriptor = fileDescriptorMap.get(file.getName());
  // create builder using the FileDescriptor
  // this can only find the top level message types
  return fileDescriptor.findMessageTypeByName(messageType);

}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private static DescriptorProtos.FileDescriptorProto containsMessageType(
  DescriptorProtos.FileDescriptorProto fileDescriptorProto, String messageType
) {
  DescriptorProtos.FileDescriptorProto file = null;
  for (DescriptorProtos.DescriptorProto descriptorProto :
    getAllMessageTypesInDescriptorProto(fileDescriptorProto)) {
    if (messageType.equals(descriptorProto.getName())) {
      file = fileDescriptorProto;
      break;
    }
  }
  return file;
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private static List<DescriptorProtos.DescriptorProto> getAllMessageTypesInDescriptorProto(
    DescriptorProtos.FileDescriptorProto fileDescriptorProto
) {
  Queue<DescriptorProtos.DescriptorProto> queue = new LinkedList<>();
  queue.addAll(fileDescriptorProto.getMessageTypeList());
  List<DescriptorProtos.DescriptorProto> result = new ArrayList<>();
  while (!queue.isEmpty()) {
    DescriptorProtos.DescriptorProto descriptorProto = queue.poll();
    queue.addAll(descriptorProto.getNestedTypeList());
    result.add(descriptorProto);
  }
  return result;
}
 

import com.google.protobuf.DescriptorProtos; //导入方法依赖的package包/类
private static Set<Descriptors.FileDescriptor> getDependencies(
    Map<String, Set<Descriptors.FileDescriptor>> dependenciesMap,
    Map<String, Descriptors.FileDescriptor> fileDescriptorMap,
    DescriptorProtos.FileDescriptorProto file,
    DescriptorProtos.FileDescriptorSet set
) throws StageException {
  Set<Descriptors.FileDescriptor> result = new LinkedHashSet<>();
  for (String name : file.getDependencyList()) {
    DescriptorProtos.FileDescriptorProto fileDescriptorProto = null;
    for (DescriptorProtos.FileDescriptorProto fdp : set.getFileList()) {
      if (name.equals(fdp.getName())) {
        fileDescriptorProto = fdp;
        break;
      }
    }
    if (fileDescriptorProto == null) {
      // could not find the message type from all the proto files contained in the descriptor file
      throw new StageException(Errors.PROTOBUF_01, file.getName());
    }
    Descriptors.FileDescriptor fileDescriptor;
    if (fileDescriptorMap.containsKey(fileDescriptorProto.getName())) {
      fileDescriptor = fileDescriptorMap.get(fileDescriptorProto.getName());
    } else {
      Set<Descriptors.FileDescriptor> deps = new LinkedHashSet<>();
      if (dependenciesMap.containsKey(name)) {
        deps.addAll(dependenciesMap.get(name));
      } else {
        deps.addAll(getDependencies(dependenciesMap, fileDescriptorMap, fileDescriptorProto, set));
      }
      try {
        fileDescriptor = Descriptors.FileDescriptor.buildFrom(
            fileDescriptorProto,
            deps.toArray(new Descriptors.FileDescriptor[deps.size()])
        );
      } catch (Descriptors.DescriptorValidationException e) {
        throw new StageException(Errors.PROTOBUF_07, e.getDescription(), e);
      }
    }
    result.add(fileDescriptor);
  }
  return result;
}