Java Maps.uniqueIndex方法代码示例

import com.google.common.collect.Maps; //导入方法依赖的package包/类
public AbstractStructSchema(
    ModelType<T> type,
    Iterable<ModelProperty<?>> properties,
    Iterable<WeaklyTypeReferencingMethod<?, ?>> nonPropertyMethods,
    Iterable<ModelSchemaAspect> aspects
) {
    super(type);
    ImmutableSortedMap.Builder<String, ModelProperty<?>> builder = ImmutableSortedMap.naturalOrder();
    for (ModelProperty<?> property : properties) {
        builder.put(property.getName(), property);
    }
    this.properties = builder.build();
    this.nonPropertyMethods = ImmutableSet.copyOf(nonPropertyMethods);
    this.aspects = Maps.uniqueIndex(aspects, new Function<ModelSchemaAspect, Class<? extends ModelSchemaAspect>>() {
        @Override
        public Class<? extends ModelSchemaAspect> apply(ModelSchemaAspect aspect) {
            return aspect.getClass();
        }
    });
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
private <T extends MemgraphObject> Iterable<T> sortMemgraphObjectsByResultOrder(Iterable<T> MemgraphObjects, List<String> ids) {
    ImmutableMap<String, T> itemMap = Maps.uniqueIndex(MemgraphObjects, MemgraphObject -> {
        if (MemgraphObject instanceof Element) {
            return ((Element) MemgraphObject).getId();
        } else if (MemgraphObject instanceof ExtendedDataRow) {
            return ElasticsearchExtendedDataIdUtils.toDocId(((ExtendedDataRow) MemgraphObject).getId());
        } else {
            throw new MemgraphException("Unhandled searchable item type: " + MemgraphObject.getClass().getName());
        }
    });

    List<T> results = new ArrayList<>();
    for (String id : ids) {
        T item = itemMap.get(id);
        if (item != null) {
            results.add(item);
        }
    }
    return results;
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
public InsertFromSubQueryAnalyzedStatement(AnalyzedRelation subQueryRelation,
                                           DocTableInfo tableInfo,
                                           List<Reference> targetColumns,
                                           @Nullable Map<Reference, Symbol> onDuplicateKeyAssignments) {
    this.targetTable = tableInfo;
    this.subQueryRelation = subQueryRelation;
    this.onDuplicateKeyAssignments = onDuplicateKeyAssignments;
    this.targetColumns = targetColumns;
    Map<ColumnIdent, Integer> columnPositions = toPositionMap(targetColumns);

    clusteredByIdx = MoreObjects.firstNonNull(columnPositions.get(tableInfo.clusteredBy()), -1);
    ImmutableMap<ColumnIdent, GeneratedReferenceInfo> generatedColumns =
            Maps.uniqueIndex(tableInfo.generatedColumns(), ReferenceInfo.TO_COLUMN_IDENT);

    if (tableInfo.hasAutoGeneratedPrimaryKey()) {
        this.primaryKeySymbols = Collections.emptyList();
    } else {
        this.primaryKeySymbols = symbolsFromTargetColumnPositionOrGeneratedExpression(
                columnPositions, targetColumns, tableInfo.primaryKey(), generatedColumns);
    }
    this.partitionedBySymbols = symbolsFromTargetColumnPositionOrGeneratedExpression(
            columnPositions, targetColumns, tableInfo.partitionedBy(), generatedColumns);
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
public KubeCloudClient(@Nullable String serverUuid,
                       @NotNull String cloudProfileId,
                       @NotNull KubeApiConnector apiConnector,
                       @NotNull List<KubeCloudImage> images,
                       @NotNull KubeCloudClientParametersImpl kubeClientParams,
                       @NotNull BuildAgentPodTemplateProviders podTemplateProviders,
                       @NotNull KubeDataCache cache,
                       @NotNull KubeBackgroundUpdater updater) {
    myServerUuid = serverUuid;
    myCloudProfileId = cloudProfileId;
    myApiConnector = apiConnector;
    myImageIdToImageMap = new ConcurrentHashMap<>(Maps.uniqueIndex(images, CloudImage::getId));
    myKubeClientParams = kubeClientParams;
    myPodTemplateProviders = podTemplateProviders;
    myCache = cache;
    myUpdater = updater;
    myUpdater.registerClient(this);
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
@Override
public synchronized void onRepositoryChange(String namespace, Properties newProperties) {
  if (newProperties.equals(m_configProperties)) {
    return;
  }
  Properties newConfigProperties = new Properties();
  newConfigProperties.putAll(newProperties);

  List<ConfigChange>
      changes =
      calcPropertyChanges(namespace, m_configProperties, newConfigProperties);
  Map<String, ConfigChange> changeMap = Maps.uniqueIndex(changes,
      new Function<ConfigChange, String>() {
        @Override
        public String apply(ConfigChange input) {
          return input.getPropertyName();
        }
      });

  m_configProperties = newConfigProperties;
  clearConfigCache();

  this.fireConfigChange(new ConfigChangeEvent(m_namespace, changeMap));

  Tracer.logEvent("Apollo.Client.ConfigChanges", m_namespace);
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
private static ImmutableMap<Wrapper<Method>, WeaklyTypeReferencingMethod<?, ?>> indexBySignature(Iterable<WeaklyTypeReferencingMethod<?, ?>> methods) {
    return Maps.uniqueIndex(methods, new Function<WeaklyTypeReferencingMethod<?, ?>, Wrapper<Method>>() {
        @Override
        public Wrapper<Method> apply(WeaklyTypeReferencingMethod<?, ?> weakMethod) {
            return SIGNATURE_EQUIVALENCE.wrap(weakMethod.getMethod());
        }
    });
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
public void configureRoot(Project rootProject) {
    Set<Project> projects = Sets.filter(rootProject.getAllprojects(), HAS_ECLIPSE_PLUGIN);
    ImmutableMap<EclipseProject, Project> eclipseProjects = Maps.uniqueIndex(projects, GET_ECLIPSE_PROJECT);
    HierarchicalElementDeduplicator<EclipseProject> deduplicator = new HierarchicalElementDeduplicator<EclipseProject>(new EclipseDeduplicationAdapter(eclipseProjects));
    Map<EclipseProject, String> deduplicated = deduplicator.deduplicate(eclipseProjects.keySet());
    for (Map.Entry<EclipseProject, String> entry : deduplicated.entrySet()) {
        entry.getKey().setName(entry.getValue());
    }
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
public DefaultTaskClassValidatorExtractor(Iterable<? extends PropertyAnnotationHandler> customAnnotationHandlers) {
    Iterable<PropertyAnnotationHandler> allAnnotationHandlers = Iterables.concat(HANDLERS, customAnnotationHandlers);
    this.annotationHandlers = Maps.uniqueIndex(allAnnotationHandlers, new Function<PropertyAnnotationHandler, Class<? extends Annotation>>() {
        @Override
        public Class<? extends Annotation> apply(PropertyAnnotationHandler handler) {
            return handler.getAnnotationType();
        }
    });
    this.annotationOverrides = collectAnnotationOverrides(allAnnotationHandlers);
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
/**
 * Takes this AnswerKey as ground truth, and takes unannotated or assessed Responses in fallback
 * and adds them to the AnswerKey.
 *
 * If the CAS for an AssessedResponse is known, prefer that CAS to the CAS in fallback.
 *
 * Does not handle the case where the fallback AnswerKey has an Assessment that this AnswerKey
 * does not.
 */
public AnswerKey copyFallingBackTo(AnswerKey fallback) {
  final Builder ret = modifiedCopyBuilder();

  final ImmutableMap<String, Response> unannotatedHere = Maps.uniqueIndex(unannotatedResponses(),
      ResponseFunctions.uniqueIdentifier());
  final ImmutableMap<String, AssessedResponse> idToAssessedHere =
      Maps.uniqueIndex(annotatedResponses(),
          Functions.compose(ResponseFunctions.uniqueIdentifier(),
              AssessedResponseFunctions.response()));
  final Set<String> idsHere = Sets.union(unannotatedHere.keySet(), idToAssessedHere.keySet());

  final ImmutableMap<String, Response> unannotatedThere = Maps.uniqueIndex(
      fallback.unannotatedResponses(), ResponseFunctions.uniqueIdentifier());
  final ImmutableMap<String, AssessedResponse> idToAssessedThere =
      Maps.uniqueIndex(fallback.annotatedResponses(),
          Functions.compose(ResponseFunctions.uniqueIdentifier(),
              AssessedResponseFunctions.response()));
  final Set<String> idsThere = Sets.union(unannotatedThere.keySet(), idToAssessedThere.keySet());

  final Set<String> idsOnlyInFallback = Sets.difference(idsThere, idsHere);
  for (final String id : idsOnlyInFallback) {
    if (unannotatedThere.containsKey(id)) {
      ret.addUnannotated(unannotatedThere.get(id));
    }
    if (idToAssessedThere.containsKey(id)) {
      final AssessedResponse r = idToAssessedThere.get(id);
      final int CASGroup;
      if (corefAnnotation().CASesToIDs().containsKey(r.response().canonicalArgument())) {
        CASGroup = corefAnnotation().CASesToIDs().get(r.response().canonicalArgument());
      } else {
        CASGroup = fallback.corefAnnotation().CASesToIDs().get(r.response().canonicalArgument());
      }
      ret.addAnnotated(r, CASGroup);
    }
  }
  return ret.build();
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
private Map<String, Field> getFieldMap(List<Field> fields) {
  Map<String, Field> fieldMap = Maps.uniqueIndex(fields, new Function<Field, String>() {
    @Override
    public String apply(Field field) {
      if (field.isAnnotationPresent(XStreamAlias.class)) {
        return field.getAnnotation(XStreamAlias.class).value();
      }
      return field.getName();
    }
  });
  return fieldMap;
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
AppServiceDomainImpl(String name, DomainInner innerObject, AppServiceManager manager) {
    super(name, innerObject, manager);
    inner().withLocation("global");
    if (inner().managedHostNames() != null) {
        this.hostNameMap = Maps.uniqueIndex(inner().managedHostNames(), new Function<HostName, String>() {
            @Override
            public String apply(HostName input) {
                return input.name();
            }
        });
    }
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
/**
 * 根据实体记录，输出Map<Long id,K extend BaseEntity>集合
 * @param list
 * @return
 */
public static<V extends AbstractIntegerEntity> Map<Integer,V> entityMaps(List<V> list){
        Map<Integer,V> maps = Maps.uniqueIndex(list.iterator(),  new Function<V, Integer>() {
        @Override
        public Integer apply(V entity) {
            return entity.getId();
        }
    });
    return maps;
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
/**
 * 根据实体记录，输出Map<Long id,K extend BaseEntity>集合
 * @param list
 * @return
 */
public static<V extends AbstractLongEntity> Map<Long,V> entityMaps(List<V> list){
        Map<Long,V> maps = Maps.uniqueIndex(list.iterator(),  new Function<V, Long>() {
        @Override
        public Long apply(V entity) {
            return entity.getId();
        }
    });
    return maps;
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
/**
 * 根据实体记录，输出Map<Long id,K extend BaseEntity>集合
 * @param list
 * @return
 */
public static<V extends AbstractStringEntity> Map<String,V> entityMaps(List<V> list){
        Map<String,V> maps = Maps.uniqueIndex(list.iterator(),  new Function<V, String>() {
        @Override
        public String apply(V entity) {
            return entity.getId();
        }
    });
    return maps;
}
 

import com.google.common.collect.Maps; //导入方法依赖的package包/类
static ReconnectForwarder forCohorts(final ConnectedClientConnection<?> successor,
        final Collection<HistoryReconnectCohort> cohorts) {
    return new BouncingReconnectForwarder(successor, Maps.uniqueIndex(Collections2.transform(cohorts,
        HistoryReconnectCohort::getProxy), ProxyReconnectCohort::getIdentifier));
}