java类com.google.common.collect.FluentIterable的实例源码

public JobUI(Job job) {
  this.jobId = job.getJobId();
  this.attempts = FluentIterable.from(job.getAttempts())
    .transform(new Function<JobAttempt, JobAttemptUI>() {
      @Override
      public JobAttemptUI apply(JobAttempt input) {
        return toUI(input);
      }
    }).toList();
  this.data = new JobDataWrapper(job.getData());
}

@Test
public void protoRegistryShouldIncludeAllProtoTypesFromFile() {
  Set<GraphQLType> graphQLTypes =
      ProtoRegistry.newBuilder().add(TestProto.getDescriptor()).build().listTypes();
  assertThat(FluentIterable.from(graphQLTypes).transform(GET_NAME))
      .containsExactly(
          "javatests_com_google_api_graphql_rejoiner_proto_Proto1",
          "javatests_com_google_api_graphql_rejoiner_proto_Proto2",
          "javatests_com_google_api_graphql_rejoiner_proto_Proto1_InnerProto",
          "javatests_com_google_api_graphql_rejoiner_proto_Proto2_TestEnum",
          "Input_javatests_com_google_api_graphql_rejoiner_proto_Proto1",
          "Input_javatests_com_google_api_graphql_rejoiner_proto_Proto2",
          "Input_javatests_com_google_api_graphql_rejoiner_proto_Proto1_InnerProto");
}

/**
 * Get all responses, assessed and unassessed
 */
public ImmutableSet<Response> allResponses() {
  return ImmutableSet.copyOf(
      concat(FluentIterable.from(annotatedResponses())
              .transform(AssessedResponseFunctions.response()),
          unannotatedResponses()));
}

private void createAppMasterRole(String appId, String operator) {
  Set<Permission> appPermissions =
      FluentIterable.from(Lists.newArrayList(
          PermissionType.CREATE_CLUSTER, PermissionType.CREATE_NAMESPACE, PermissionType.ASSIGN_ROLE))
          .transform(permissionType -> createPermission(appId, permissionType, operator)).toSet();
  Set<Permission> createdAppPermissions = rolePermissionService.createPermissions(appPermissions);
  Set<Long>
      appPermissionIds =
      FluentIterable.from(createdAppPermissions).transform(permission -> permission.getId()).toSet();

  //create app master role
  Role appMasterRole = createRole(RoleUtils.buildAppMasterRoleName(appId), operator);

  rolePermissionService.createRoleWithPermissions(appMasterRole, appPermissionIds);
}

/**
 * Gets an identifier corresponding to the ERE object the response aligns to, if any.
 */
public Optional<ScoringCorefID> argumentForResponse(final Response response) {
  if (response.role().equalTo(TIME)) {
    // time is a special case; its CAS is always its TIMEX form
    return Optional.of(new ScoringCorefID.Builder().scoringEntityType(ScoringEntityType.Time)
        .withinTypeID(response.canonicalArgument().string()).build());
  }

  final MappedEventTypeRole systemTypeRole = typeRoleForResponse(response);
  final ImmutableSet<CandidateAlignmentTarget> searchOrder =
      FluentIterable.from(candidateEREObjects)
          // alignment candidates which match the response in event type
          // and argument role will always be searched before other candidates
          // in order to be as generous as possible to systems.
          // Note ImmutableSets iterate deterministically in the order of insertion
          .filter(compose(containsElement(systemTypeRole), typeRolesSeen()))
          .append(candidateEREObjects)
          .toSet();

  // for each alignment rule in order, try to find an ERE object which aligns
  for (final ResponseToEREAlignmentRule responseChecker : responseMatchingStrategy) {
    for (final CandidateAlignmentTarget alignmentCandidate : searchOrder) {
      if (responseChecker.aligns(response, alignmentCandidate)) {
        return Optional.of(alignmentCandidate.id());
      }
    }
  }

  return Optional.absent();
}

private static Set<Location> jarLocationsOf(URLClassLoader loader) {
    return FluentIterable.from(Locations.of(ImmutableSet.copyOf(loader.getURLs())))
            .filter(new Predicate<Location>() {
                @Override
                public boolean apply(Location input) {
                    return input.isJar();
                }
            }).toSet();
}

public static List<ViewFieldType> removeUpdateColumn(final List<ViewFieldType> fields) {
  return FluentIterable.from(fields).filter(new Predicate<ViewFieldType>() {
    @Override
    public boolean apply(@Nullable ViewFieldType input) {
      return !IncrementalUpdateUtils.UPDATE_COLUMN.equals(input.getName());
    }
  }).toList();
}

private LayoutContainerDescriptor toIntentMessage(final LayoutContainerApiDescriptor descriptor) {
  return new LayoutContainerDescriptor()
      .setEnabled(descriptor.getEnabled())
      .setType(descriptor.getType())
      .setLayoutList(FluentIterable
          .from(descriptor.getLayoutList())
          .transform(new Function<LayoutApiDescriptor, LayoutDescriptor>() {
            @Nullable
            @Override
            public LayoutDescriptor apply(@Nullable final LayoutApiDescriptor input) {
              final LayoutDetailsApiDescriptor details = input.getDetails();
              return new LayoutDescriptor()
                  .setId(toLayoutId(input.getId()))
                  .setName(input.getName())
                  .setDetails(new LayoutDetailsDescriptor()
                      .setDisplayFieldList(toIntentFields(details.getDisplayFieldList()))
                      .setMeasureFieldList(toIntentFields(details.getMeasureFieldList()))
                      .setDimensionFieldList(toIntentDimensionFields(details.getDimensionFieldList()))
                      .setPartitionFieldList(toIntentFields(details.getPartitionFieldList()))
                      .setSortFieldList(toIntentFields(details.getSortFieldList()))
                      .setDistributionFieldList(toIntentFields(details.getDistributionFieldList()))
                      .setPartitionDistributionStrategy(details.getPartitionDistributionStrategy())
                  );
            }
          })
          .toList()
      );
}

@Override
public ImmutableSet<Symbol> docIDs() throws IOException {
  return FluentIterable.from(Arrays.asList(directory.listFiles()))
      .transform(FileUtils.ToName)
      .transform(Symbol.FromString)
      .toSet();
}

public List<LayoutField> toLayoutFields(final List<LayoutFieldDescriptor> fields) {
  return FluentIterable.from(AccelerationUtils.selfOrEmpty(fields))
      .transform(new Function<LayoutFieldDescriptor, LayoutField>() {
        @Nullable
        @Override
        public LayoutField apply(@Nullable final LayoutFieldDescriptor field) {
          return toLayoutField(field);
        }
      })
      .toList();
}