Java Code Examples for com.google.common.collect.Multimaps#index()

private void discoverShards()
{
    log.info("Discovering shards that need compaction...");
    Set<ShardMetadata> allShards = shardManager.getNodeShards(currentNodeIdentifier);
    ListMultimap<Long, ShardMetadata> tableShards = Multimaps.index(allShards, ShardMetadata::getTableId);

    for (Entry<Long, List<ShardMetadata>> entry : Multimaps.asMap(tableShards).entrySet()) {
        long tableId = entry.getKey();
        if (!metadataDao.isCompactionEligible(tableId)) {
            continue;
        }
        List<ShardMetadata> shards = entry.getValue();
        Collection<OrganizationSet> organizationSets = filterAndCreateCompactionSets(tableId, shards);
        log.info("Created %s organization set(s) for table ID %s", organizationSets.size(), tableId);

        for (OrganizationSet set : organizationSets) {
            organizer.enqueue(set);
        }
    }
}
 

@Test
public void testGroupBy(){
	List<UserEntity> all = LangUtils.newArrayList();
	List<UserEntity> aa = createSameNameUserList("aa", 3);
	List<UserEntity> bb = createSameNameUserList("bb", 1);
	List<UserEntity> cc = createSameNameUserList("cc", 2);
	all.addAll(aa);
	all.addAll(bb);
	all.addAll(cc);
	
	ImmutableListMultimap<String, UserEntity> groups = Multimaps.index(all, new Function<UserEntity, String>() {

		@Override
		public String apply(UserEntity input) {
			return input.getUserName();
		}
		
	});
	
	System.out.println("groups:" + groups);
	Assert.assertEquals(3, groups.get("aa").size());
	Assert.assertEquals(1, groups.get("bb").size());
	Assert.assertEquals(2, groups.get("cc").size());
	
	Map<String, List<UserEntity>> userGroup = all.stream().collect(Collectors.groupingBy(u->u.getUserName()));
	System.out.println("userGroup:" + userGroup);
	Assert.assertEquals(3, userGroup.get("aa").size());
	Assert.assertEquals(1, userGroup.get("bb").size());
	Assert.assertEquals(2, userGroup.get("cc").size());
}
 

private static ImmutableListMultimap<String, DescriptorProtos.SourceCodeInfo.Location>
    buildLocationMap(FileDescriptorProto file) {
  return Multimaps.<String, DescriptorProtos.SourceCodeInfo.Location>index(
      file.getSourceCodeInfo().getLocationList(),
      new Function<DescriptorProtos.SourceCodeInfo.Location, String>() {
        @Override
        public String apply(DescriptorProtos.SourceCodeInfo.Location location) {
          return DOT_JOINER.join(location.getPathList());
        }
      });
}
 

FactoryMethodDescriptor generateDescriptorForConstructor(final AutoFactoryDeclaration declaration,
    ExecutableElement constructor) {
  checkNotNull(constructor);
  checkArgument(constructor.getKind() == ElementKind.CONSTRUCTOR);
  TypeElement classElement = MoreElements.asType(constructor.getEnclosingElement());
  ImmutableListMultimap<Boolean, ? extends VariableElement> parameterMap =
      Multimaps.index(constructor.getParameters(), Functions.forPredicate(
          new Predicate<VariableElement>() {
            @Override
            public boolean apply(VariableElement parameter) {
              return isAnnotationPresent(parameter, Provided.class);
            }
          }));
  ImmutableSet<Parameter> providedParameters =
      Parameter.forParameterList(parameterMap.get(true), types);
  ImmutableSet<Parameter> passedParameters =
      Parameter.forParameterList(parameterMap.get(false), types);
  return FactoryMethodDescriptor.builder(declaration)
      .name("create")
      .returnType(classElement.asType())
      .publicMethod(classElement.getModifiers().contains(PUBLIC))
      .providedParameters(providedParameters)
      .passedParameters(passedParameters)
      .creationParameters(Parameter.forParameterList(constructor.getParameters(), types))
      .isVarArgs(constructor.isVarArgs())
      .build();
}
 

public void load() {
    tabbedPane.removeAll();

    List<Plugin> plugins = Session.get().getPluginManager().getPlugins();
    Multimap<String, Plugin> pluginGroups = Multimaps.index(plugins, Plugin::getGroup);
    for (String groupName : pluginGroups.keySet()) {
        PluginGroup group = new PluginGroup(groupName, pluginGroups.get(groupName));
        tabbedPane.addTab(group.getName(), group);
    }

    MateTabbedPane.Tab first = tabbedPane.getAt(0);
    if (first != null) {
        first.select();
    }
}
 

/**
 * Returns a list sorted according to related groups of types.
 *
 * @param objects
 *          collection to sort
 * @param mapping
 *          mapping function
 * @param <T>
 *          object type
 * @return sorted list
 */
public static <T> ListMultimap<EPackage, T> sortedEPackageGroups(final Iterable<T> objects, final Function<T, EClass> mapping) {
  ListMultimap<EPackage, T> index = Multimaps.index(objects, new Function<T, EPackage>() {
    @Override
    public EPackage apply(final T from) {
      return mapping.apply(from).getEPackage();
    }
  });
  ListMultimap<EPackage, T> result = LinkedListMultimap.create(index.keySet().size());
  for (EPackage pkg : index.keySet()) {
    result.putAll(pkg, sortedGroups(index.get(pkg), mapping));
  }
  return result;
}
 

private static ImmutableMultimap<TypeRoleFillerRealis, AssessedResponse> getEquivClassToAssessedResponse(final AnswerKey answerKey) {
  final Function<Response, TypeRoleFillerRealis> equivalenceClassFunction =
      TypeRoleFillerRealis.extractFromSystemResponse(answerKey
          .corefAnnotation().strictCASNormalizerFunction());

  final ImmutableMultimap<TypeRoleFillerRealis, AssessedResponse> equivClassToAnswerKeyResponses =
      Multimaps.index(
          answerKey.annotatedResponses(),
          Functions.compose(equivalenceClassFunction, AssessedResponseFunctions.response()));

  return equivClassToAnswerKeyResponses;
}
 

@Override
public Multimap<String, IScheduledTask> createNamedGroups(Iterable<IScheduledTask> tasks) {
  return Multimaps.index(tasks, Functions.compose(new Function<IJobKey, String>() {
    @Override
    public String apply(IJobKey jobKey) {
      return "sla_" + JobKeys.canonicalString(jobKey) + "_";
    }
  }, Tasks::getJob));
}
 

public Result writeDiscovery(
    Iterable<ApiConfig> configs, DiscoveryContext context, SchemaRepository schemaRepository) {
  ImmutableListMultimap<ApiKey, ApiConfig> configsByKey = Multimaps.index(configs,
      new Function<ApiConfig, ApiKey>() {
        @Override public ApiKey apply(ApiConfig config) {
          return config.getApiKey();
        }
      });
  ImmutableMap.Builder<ApiKey, RestDescription> builder = ImmutableMap.builder();
  // "Default" API versions were determined automagically in legacy endpoints.
  // This version only allows to remove an API from default ones by adding
  // defaultVersion = AnnotationBoolean.FALSE to @Api
  ImmutableSet.Builder<ApiKey> preferred = ImmutableSet.builder();
  for (ApiKey apiKey : configsByKey.keySet()) {
    ImmutableList<ApiConfig> apiConfigs = configsByKey.get(apiKey);
    if (context.generateAll || apiConfigs.get(0).getIsDiscoverable()) {
      builder.put(apiKey, writeApi(apiKey, apiConfigs, context, schemaRepository));
      // last config takes precedence (same as writeApi)
      if (Iterables.getLast(apiConfigs).getIsDefaultVersion()) {
        preferred.add(apiKey);
      }
    }
  }
  ImmutableMap<ApiKey, RestDescription> discoveryDocs = builder.build();
  return Result.builder()
      .setDiscoveryDocs(discoveryDocs)
      .setDirectory(generateDirectory(discoveryDocs, preferred.build(), context))
      .build();
}
 

@Override
public List<ConfiguredTarget> getPrerequisites(
    QueryExpression caller,
    ConfiguredTarget configuredTarget,
    String attrName,
    String errorMsgPrefix)
    throws QueryException, InterruptedException {
  Preconditions.checkArgument(
      isRule(configuredTarget),
      "%s %s is not a rule configured target",
      errorMsgPrefix,
      getLabel(configuredTarget));

  Multimap<Label, ConfiguredTarget> depsByLabel =
      Multimaps.index(
          queryEnvironment.getFwdDeps(ImmutableList.of(configuredTarget)),
          ConfiguredTarget::getLabel);

  Rule rule = (Rule) getTargetFromConfiguredTarget(configuredTarget);
  ImmutableMap<Label, ConfigMatchingProvider> configConditions =
      ((RuleConfiguredTarget) configuredTarget).getConfigConditions();
  ConfiguredAttributeMapper attributeMapper =
      ConfiguredAttributeMapper.of(rule, configConditions);
  if (!attributeMapper.has(attrName)) {
    throw new QueryException(
        caller,
        String.format(
            "%s %s of type %s does not have attribute '%s'",
            errorMsgPrefix, configuredTarget, rule.getRuleClass(), attrName));
  }
  ImmutableList.Builder<ConfiguredTarget> toReturn = ImmutableList.builder();
  attributeMapper.visitLabels(attributeMapper.getAttributeDefinition(attrName)).stream()
      .forEach(depEdge -> toReturn.addAll(depsByLabel.get(depEdge.getLabel())));
  return toReturn.build();
}
 

@Override
@Timed("snapshot_deduplicate")
public DeduplicatedSnapshot deduplicate(Snapshot snapshot) {
  int numInputTasks = snapshot.getTasksSize();
  LOG.info("Starting deduplication of a snapshot with {} tasks.", numInputTasks);

  DeduplicatedSnapshot deduplicatedSnapshot = new DeduplicatedSnapshot()
      .setPartialSnapshot(deepCopyWithoutTasks(snapshot));

  // Nothing to do if we don't have any input tasks.
  if (!snapshot.isSetTasks()) {
    LOG.warn("Got snapshot with unset tasks field.");
    return deduplicatedSnapshot;
  }

  // Match each unique TaskConfig to its hopefully-multiple ScheduledTask owners.
  ListMultimap<TaskConfig, ScheduledTask> index = Multimaps.index(
      snapshot.getTasks(),
      SCHEDULED_TO_CONFIG);

  for (Entry<TaskConfig, List<ScheduledTask>> entry : Multimaps.asMap(index).entrySet()) {
    deduplicatedSnapshot.addToTaskConfigs(entry.getKey());
    for (ScheduledTask scheduledTask : entry.getValue()) {
      deduplicatedSnapshot.addToPartialTasks(new DeduplicatedScheduledTask()
          .setPartialScheduledTask(deepCopyWithoutTaskConfig(scheduledTask))
          .setTaskConfigId(deduplicatedSnapshot.getTaskConfigsSize() - 1));
    }
  }

  int numOutputTasks = deduplicatedSnapshot.getTaskConfigsSize();

  LOG.info(String.format(
      "Finished deduplicating snapshot. Deduplication ratio: %d/%d = %.2f%%.",
      numInputTasks,
      numOutputTasks,
      100.0 * numInputTasks / numOutputTasks));

  return deduplicatedSnapshot;
}
 

@VisibleForTesting
Address getRichest(Collection<UnspentTransactionOutput> unspent, final NetworkParameters network) {
   Preconditions.checkArgument(!unspent.isEmpty());
   Function<UnspentTransactionOutput, Address> txout2Address = new Function<UnspentTransactionOutput, Address>() {
      @Override
      public Address apply(UnspentTransactionOutput input) {
         return input.script.getAddress(network);
      }
   };
   Multimap<Address, UnspentTransactionOutput> index = Multimaps.index(unspent, txout2Address);
   Address ret = getRichest(index);
   return Preconditions.checkNotNull(ret);
}
 

private void init() {

		sortedElements = Iterables.toArray(elements, IGamlDescription.class);
		if (titles == null) {
			Arrays.sort(sortedElements, (e1, e2) -> e1.getTitle().compareTo(e2.getTitle()));
		} else {
			Arrays.sort(sortedElements, (e1, e2) -> titles.get(e1).compareTo(titles.get(e2)));
		}
		byName = Multimaps.index(elements, (each) -> each.getName());

	}
 

private void assertStateUpdate(
    IJobUpdateKey key,
    JobUpdateStatus expected,
    Multimap<Integer, JobUpdateAction> expectedActions) {

  IJobUpdateDetails details = getDetails(key);
  Iterable<IJobInstanceUpdateEvent> orderedEvents =
      EVENT_ORDER.sortedCopy(details.getInstanceEvents());
  Multimap<Integer, IJobInstanceUpdateEvent> eventsByInstance =
      Multimaps.index(orderedEvents, EVENT_TO_INSTANCE);
  Multimap<Integer, JobUpdateAction> actionsByInstance =
      Multimaps.transformValues(eventsByInstance, JobUpdateControllerImpl.EVENT_TO_ACTION);
  assertEquals(expectedActions, actionsByInstance);
  assertEquals(expected, details.getUpdate().getSummary().getState().getStatus());
}
 

private Collection<IRailLink<TPos>> findRailLinksConnectingTo(TPos pos){
    if(destinationsToRailLinks == null) {
        destinationsToRailLinks = Multimaps.index(getRailLinks().iterator(), IRailLink::getDestinationPos);
    }
    return destinationsToRailLinks.get(pos);
}
 

private void updateSubstation() {
    if (substations == null) {
        LOGGER.trace("Update substations...");
        substations = new ArrayList<>();
        node2voltageLevel = new HashMap<>();
        UndirectedGraph<UcteNodeCode, Object> graph = createSubstationGraph(network);
        for (Set<UcteNodeCode> substationNodes : new ConnectivityInspector<>(graph).connectedSets()) {
            // the main node of the substation is not an xnode and the one with the highest voltage
            // level and the lowest busbar number.
            UcteNodeCode mainNode = substationNodes.stream()
                    .sorted((nodeCode1, nodeCode2) -> {
                        if (nodeCode1.getUcteCountryCode() == UcteCountryCode.XX &&
                                nodeCode2.getUcteCountryCode() != UcteCountryCode.XX) {
                            return 1;
                        } else if (nodeCode1.getUcteCountryCode() != UcteCountryCode.XX &&
                                nodeCode2.getUcteCountryCode() == UcteCountryCode.XX) {
                            return -1;
                        } else {
                            return compareVoltageLevelThenBusbar(nodeCode1, nodeCode2);
                        }
                    })
                    .findFirst()
                    .orElseThrow(AssertionError::new);

            Multimap<UcteVoltageLevelCode, UcteNodeCode> nodesByVoltageLevel
                    = Multimaps.index(substationNodes, UcteNodeCode::getVoltageLevelCode);

            String substationName = mainNode.getUcteCountryCode().getUcteCode() + mainNode.getGeographicalSpot();
            List<UcteVoltageLevel> voltageLevels = new ArrayList<>();
            UcteSubstation substation = new UcteSubstation(substationName, voltageLevels);
            substations.add(substation);

            LOGGER.trace("Define substation {}", substationName);

            for (Map.Entry<UcteVoltageLevelCode, Collection<UcteNodeCode>> entry : nodesByVoltageLevel.asMap().entrySet()) {
                UcteVoltageLevelCode vlc = entry.getKey();
                Collection<UcteNodeCode> voltageLevelNodes = entry.getValue();
                String voltageLevelName = mainNode.getUcteCountryCode().getUcteCode() + mainNode.getGeographicalSpot() + vlc.ordinal();
                UcteVoltageLevel voltageLevel = new UcteVoltageLevel(voltageLevelName, substation, voltageLevelNodes);
                voltageLevels.add(voltageLevel);
                voltageLevelNodes.forEach(voltageLevelNode -> node2voltageLevel.put(voltageLevelNode, voltageLevel));

                LOGGER.trace("Define voltage level {} as a group of {} nodes", voltageLevelName, voltageLevelNodes);
            }
        }
    }
}
 

public void update() {
    Lifecycle serverState = getAttribute(Attributes.SERVICE_STATE_ACTUAL);
    if (Lifecycle.STOPPED.equals(serverState) || Lifecycle.STOPPING.equals(serverState)
            || Lifecycle.DESTROYED.equals(serverState) || !getAttribute(Attributes.SERVICE_UP)) {
        LOG.debug("Skipped update of {} when service state is {} and running is {}",
                new Object[]{this, getAttribute(Attributes.SERVICE_STATE_ACTUAL), getAttribute(SERVICE_UP)});
        return;
    }
    synchronized (this) {
        Iterable<Entity> availableEntities = FluentIterable.from(getEntities().getMembers())
                .filter(new HasHostnameAndValidLifecycle());
        LOG.debug("{} updating with entities: {}", this, Iterables.toString(availableEntities));
        ImmutableListMultimap<String, Entity> hostnameToEntity = Multimaps.index(availableEntities,
                new HostnameTransformer());

        Map<String, String> octetToName = Maps.newHashMap();
        BiMap<String, String> ipToARecord = HashBiMap.create();
        Multimap<String, String> aRecordToCnames = MultimapBuilder.hashKeys().hashSetValues().build();
        Multimap<String, String> ipToAllNames = MultimapBuilder.hashKeys().hashSetValues().build();

        for (Map.Entry<String, Entity> entry : hostnameToEntity.entries()) {
            String domainName = entry.getKey();
            Entity entity = entry.getValue();
            
            String address = null;
            
            AttributeSensor<String> addressSensor = getConfig(ADDRESS_SENSOR);
            if (addressSensor!=null) {
                address = entity.getAttribute(addressSensor);
                
            } else {
                if (!hasLoggedDeprecationAboutAddressSensor) {
                    LOG.warn("BIND entity "+this+" is using legacy machine inspection to determine IP address; set the "+ADDRESS_SENSOR.getName()+" config to ensure compatibility with future versions");
                    hasLoggedDeprecationAboutAddressSensor = true;
                }
                Maybe<SshMachineLocation> location = Machines.findUniqueMachineLocation(entity.getLocations(), SshMachineLocation.class);
                if (!location.isPresent()) {
                    LOG.debug("Member {} of {} does not have an hostname so will not be configured", entity, this);
                } else if (ipToARecord.inverse().containsKey(domainName)) {
                    // already has a hostname, ignore (could log if domain is different?)
                } else {
                    address = location.get().getAddress().getHostAddress();
                }
            }
            
            if (Strings.isBlank(address)) {
                continue;
            }
            
            ipToAllNames.put(address, domainName);
            if (!ipToARecord.containsKey(address)) {
                ipToARecord.put(address, domainName);
                if (getReverseLookupNetwork().contains(new Cidr(address + "/32"))) {
                    String octet = Iterables.get(Splitter.on('.').split(address), 3);
                    if (!octetToName.containsKey(octet)) octetToName.put(octet, domainName);
                }
            } else {
                aRecordToCnames.put(ipToARecord.get(address), domainName);
            }
        }
        sensors().set(A_RECORDS, ImmutableMap.copyOf(ipToARecord.inverse()));
        sensors().set(PTR_RECORDS, ImmutableMap.copyOf(octetToName));
        sensors().set(CNAME_RECORDS, Multimaps.unmodifiableMultimap(aRecordToCnames));
        sensors().set(ADDRESS_MAPPINGS, Multimaps.unmodifiableMultimap(ipToAllNames));

        // Update Bind configuration files and restart the service
        getDriver().updateBindConfiguration();
   }
}
 

@Override
public Multimap<String, IScheduledTask> createNamedGroups(Iterable<IScheduledTask> tasks) {
  return Multimaps.index(tasks, task -> "sla_cluster_");
}
 

public ListMultimap<String, MediaSegmentDescriptor> lookUpSegmentsOfObjects(
    Iterable<String> objectIds) {
  Stream<MediaSegmentDescriptor> descriptors =
      this.lookUpSegmentsByField(FIELDNAMES[1], objectIds);
  return Multimaps.index(descriptors.iterator(), MediaSegmentDescriptor::getObjectId);
}
 

public static <Answerable> SystemOutputEquivalenceClasses<Answerable> forAnswerable(
    final ArgumentOutput argumentOutput, final Function<Response, Answerable> answerableExtractor) {
  return new SystemOutputEquivalenceClasses<Answerable>(argumentOutput,
      Multimaps.index(argumentOutput.responses(), answerableExtractor));
}