Java FileDescriptor.getDependencies方法代码示例

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
static Set<FileDescriptor> extractDependencies(List<FileDescriptor> fileDescriptors) {
  LinkedList<FileDescriptor> loop = new LinkedList<>(fileDescriptors);
  HashSet<FileDescriptor> fileDescriptorSet = new HashSet<>(fileDescriptors);

  while (!loop.isEmpty()) {
    FileDescriptor fileDescriptor = loop.pop();
    for (FileDescriptor dependency : fileDescriptor.getDependencies()) {
      if (!fileDescriptorSet.contains(dependency)) {
        fileDescriptorSet.add(dependency);
        loop.push(dependency);
      }
    }
  }

  return ImmutableSet.copyOf(fileDescriptorSet);
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
private FileDescriptor getDeepCanonicalFileDescriptor(final FileDescriptor file,
    final boolean forceRebuild) throws DescriptorValidationException {
  if (!forceRebuild && isDeeplyCanonical(file)) {
    return file;
  }

  final FileDescriptor[] dependencies = new FileDescriptor[file.getDependencies().size()];
  int i = 0;

  for (final FileDescriptor dependency : file.getDependencies()) {
    dependencies[i++] = getDeepCanonicalFileDescriptor(dependency, forceRebuild);
  }

  final FileDescriptorProto proto = isCanonical(file) ? file.toProto() : makeCanonicalProto(file);
  return buildFileDescriptorWithReserializedProto(proto, dependencies);
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
private FileDescriptorSet.Builder addDescriptorToFileSet(FileDescriptorSet.Builder builder, 
    Descriptor descriptor, Set<FileDescriptorProto> fileProtoSet) {
  List<? extends FileDescriptorProtoOrBuilder> fileList = builder.getFileOrBuilderList();
  final FileDescriptor file = descriptor.getFile();
  FileDescriptorProto proto = file.toProto();
  
  if (fileList.contains(proto)) {
    return builder;
  }
  
  builder.addFile(proto);
  
  for (FileDescriptor dependency : file.getDependencies()) {
    proto = dependency.toProto();
    
    if (!fileList.contains(proto)) {
      builder.addFile(proto);
    }
  }
  
  return builder;
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
private ServerReflectionResponse createServerReflectionResponse(
    ServerReflectionRequest request, FileDescriptor fd) {
  FileDescriptorResponse.Builder fdRBuilder = FileDescriptorResponse.newBuilder();

  Set<String> seenFiles = new HashSet<String>();
  Queue<FileDescriptor> frontier = new ArrayDeque<FileDescriptor>();
  seenFiles.add(fd.getName());
  frontier.add(fd);
  while (!frontier.isEmpty()) {
    FileDescriptor nextFd = frontier.remove();
    fdRBuilder.addFileDescriptorProto(nextFd.toProto().toByteString());
    for (FileDescriptor dependencyFd : nextFd.getDependencies()) {
      if (!seenFiles.contains(dependencyFd.getName())) {
        seenFiles.add(dependencyFd.getName());
        frontier.add(dependencyFd);
      }
    }
  }
  return ServerReflectionResponse.newBuilder()
      .setValidHost(request.getHost())
      .setOriginalRequest(request)
      .setFileDescriptorResponse(fdRBuilder)
      .build();
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
private void addFile(FileDescriptor file) {
  // Skip the file if it's already added.
  if (!files.add(file.getFullName())) {
    return;
  }
  for (FileDescriptor dependency : file.getDependencies()) {
    addFile(dependency);
  }
  for (Descriptor message : file.getMessageTypes()) {
    addMessage(message);
  }
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
private static Iterable<FileDescriptor> getFileWithAllDependencies(final FileDescriptor file) {
  final Set<FileDescriptor> cache = new LinkedHashSet<FileDescriptor>();

  cache.add(file);

  // we must follow the original ProtoBuf here!
  for (final FileDescriptor dependency : file.getDependencies()) {
    cache.add(dependency);
    addPublicDependencies(cache, dependency);
  }

  return cache;
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
private boolean isDeeplyCanonical(final FileDescriptor file) {
  if (!isCanonical(file)) {
    return false;
  }

  for (final FileDescriptor dependency : file.getDependencies()) {
    if (!isDeeplyCanonical(dependency)) {
      return false;
    }
  }

  return true;
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
public FileDescriptorSetBuilder addFile(final FileDescriptor file) {
  if (!fileProtoSet.add(file.toProto())) {
    return this;
  }
  
  for (FileDescriptor dependency : file.getDependencies()) {
    addFile(dependency);
  }
  
  return this;
}
 

import com.google.protobuf.Descriptors.FileDescriptor; //导入方法依赖的package包/类
FileDescriptorIndex(List<ServerServiceDefinition> services) {
  Queue<FileDescriptor> fileDescriptorsToProcess = new ArrayDeque<FileDescriptor>();
  Set<String> seenFiles = new HashSet<String>();
  for (ServerServiceDefinition service : services) {
    io.grpc.ServiceDescriptor serviceDescriptor = service.getServiceDescriptor();
    if (serviceDescriptor.getSchemaDescriptor() instanceof ProtoFileDescriptorSupplier) {
      FileDescriptor fileDescriptor =
          ((ProtoFileDescriptorSupplier) serviceDescriptor.getSchemaDescriptor())
              .getFileDescriptor();
      String serviceName = serviceDescriptor.getName();
      checkState(
          !serviceNames.contains(serviceName), "Service already defined: %s", serviceName);
      serviceFileDescriptors.add(fileDescriptor);
      serviceNames.add(serviceName);
      if (!seenFiles.contains(fileDescriptor.getName())) {
        seenFiles.add(fileDescriptor.getName());
        fileDescriptorsToProcess.add(fileDescriptor);
      }
    }
  }

  while (!fileDescriptorsToProcess.isEmpty()) {
    FileDescriptor currentFd = fileDescriptorsToProcess.remove();
    processFileDescriptor(currentFd);
    for (FileDescriptor dependencyFd : currentFd.getDependencies()) {
      if (!seenFiles.contains(dependencyFd.getName())) {
        seenFiles.add(dependencyFd.getName());
        fileDescriptorsToProcess.add(dependencyFd);
      }
    }
  }
}