Java Code Examples for com.google.common.collect.ImmutableMultimap#copyOf()

Space(Multimap<Method, MetadataHandler> providerMap) {
  this.providerMap = ImmutableMultimap.copyOf(providerMap);

  // Find the distinct set of RelNode classes handled by this provider,
  // ordered base-class first.
  for (Map.Entry<Method, MetadataHandler> entry : providerMap.entries()) {
    final Method method = entry.getKey();
    final MetadataHandler provider = entry.getValue();
    for (final Method handlerMethod : provider.getClass().getMethods()) {
      if (couldImplement(handlerMethod, method)) {
        @SuppressWarnings("unchecked") final Class<RelNode> relNodeClass =
            (Class<RelNode>) handlerMethod.getParameterTypes()[0];
        classes.add(relNodeClass);
        handlerMap.put(Pair.of(relNodeClass, method), handlerMethod);
      }
    }
  }
}
 

@Override
public void registerSpawnStrategies(
    SpawnStrategyRegistry.Builder registryBuilder, CommandEnvironment env) {
  Preconditions.checkNotNull(workerPool);
  SandboxOptions sandboxOptions = env.getOptions().getOptions(SandboxOptions.class);
  ImmutableMultimap<String, String> extraFlags =
      ImmutableMultimap.copyOf(env.getOptions().getOptions(WorkerOptions.class).workerExtraFlags);
  LocalEnvProvider localEnvProvider = LocalEnvProvider.forCurrentOs(env.getClientEnv());
  WorkerSpawnRunner spawnRunner =
      new WorkerSpawnRunner(
          new SandboxHelpers(sandboxOptions.delayVirtualInputMaterialization),
          env.getExecRoot(),
          workerPool,
          extraFlags,
          env.getReporter(),
          createFallbackRunner(env, localEnvProvider),
          localEnvProvider,
          sandboxOptions.symlinkedSandboxExpandsTreeArtifactsInRunfilesTree,
          env.getBlazeWorkspace().getBinTools(),
          env.getLocalResourceManager(),
          // TODO(buchgr): Replace singleton by a command-scoped RunfilesTreeUpdater
          RunfilesTreeUpdater.INSTANCE);
  registryBuilder.registerStrategy(
      new WorkerSpawnStrategy(env.getExecRoot(), spawnRunner), "worker");
}
 

@Test
public void executeLetsTheLocalUserCreatorCreateAUser() throws Exception {
  Map<String, String> userInfo = Maps.newHashMap();
  userInfo.put(UserInfoKeys.USER_PID, PID);
  userInfo.put(UserInfoKeys.USER_NAME, USER_NAME);
  userInfo.put(UserInfoKeys.PASSWORD, PWD);
  userInfo.put(UserInfoKeys.GIVEN_NAME, GIVEN_NAME);
  userInfo.put(UserInfoKeys.SURNAME, SURNAME);
  userInfo.put(UserInfoKeys.EMAIL_ADDRESS, EMAIL);
  userInfo.put(UserInfoKeys.ORGANIZATION, ORGANIZATION);
  userInfo.put(UserInfoKeys.VRE_ID, VRE_ID);
  userInfo.put(UserInfoKeys.VRE_ROLE, VRE_ROLE);
  ImmutableMultimap<String, String> immutableMultimap = ImmutableMultimap.copyOf(userInfo.entrySet());

  instance.execute(immutableMultimap, mock(PrintWriter.class));

  verify(localUserCreator).create(userInfo);
}
 

Space(Multimap<Method, MetadataHandler> providerMap) {
  this.providerMap = ImmutableMultimap.copyOf(providerMap);

  // Find the distinct set of RelNode classes handled by this provider,
  // ordered base-class first.
  for (Map.Entry<Method, MetadataHandler> entry : providerMap.entries()) {
    final Method method = entry.getKey();
    final MetadataHandler provider = entry.getValue();
    for (final Method handlerMethod : provider.getClass().getMethods()) {
      if (couldImplement(handlerMethod, method)) {
        @SuppressWarnings("unchecked") final Class<RelNode> relNodeClass =
            (Class<RelNode>) handlerMethod.getParameterTypes()[0];
        classes.add(relNodeClass);
        handlerMap.put(Pair.of(relNodeClass, method), handlerMethod);
      }
    }
  }
}
 

/**
 * Get a copy of all {@link StoredClientChannel}s
 */
public Multimap<Sha256Hash, StoredClientChannel> getChannelMap() {
    lock.lock();
    try {
        return ImmutableMultimap.copyOf(mapChannels);
    } finally {
        lock.unlock();
    }
}
 

/**
 * Unregisters all subscribed methods from provided subscriber object.
 *
 * @param object object to unsubscribe from
 */
public synchronized void unregister(@Nonnull final Object object)
{
	if (subscribers == null)
	{
		return;
	}

	final Multimap<Class, Subscriber> map = HashMultimap.create();
	map.putAll(subscribers);

	for (Class<?> clazz = object.getClass(); clazz != null; clazz = clazz.getSuperclass())
	{
		for (final Method method : clazz.getDeclaredMethods())
		{
			final Subscribe sub = method.getAnnotation(Subscribe.class);

			if (sub == null)
			{
				continue;
			}

			final Class<?> parameterClazz = method.getParameterTypes()[0];
			map.remove(parameterClazz, new Subscriber(object, method, sub.priority(), null));
		}
	}

	subscribers = ImmutableMultimap.copyOf(map);
}
 

public CodeReferenceMap build() {
  ImmutableTable.Builder<String, String, ImmutableSet<String>> deadMethodsBuilder =
      ImmutableTable.builder();
  for (Table.Cell<String, String, Set<String>> cell : this.deadMethods.cellSet()) {
    deadMethodsBuilder.put(
        cell.getRowKey(),
        cell.getColumnKey(),
        ImmutableSet.copyOf(cell.getValue()));
  }
  return new CodeReferenceMap(
      ImmutableSet.copyOf(deadClasses),
      deadMethodsBuilder.build(),
      ImmutableMultimap.copyOf(deadFields));
}
 

public static ImmutableMultimap<String, String> calculateGroupMembershipToAdd(UmsUsersState umsState, UsersState ipaState) {
    Multimap<String, String> groupMembershipToAdd = HashMultimap.create();
    umsState.getUsersState().getGroupMembership().forEach((group, user) -> {
        if (!FreeIpaChecks.IPA_UNMANAGED_GROUPS.contains(group) && !ipaState.getGroupMembership().containsEntry(group, user)) {
            LOGGER.debug("adding user : {} to group : {}", user, group);
            groupMembershipToAdd.put(group, user);
        }
    });

    LOGGER.info("groupMembershipToAdd size = {}", groupMembershipToAdd.size());
    LOGGER.debug("groupMembershipToAdd = {}", groupMembershipToAdd.asMap());

    return ImmutableMultimap.copyOf(groupMembershipToAdd);
}
 

/**
 * Get a copy of all {@link StoredClientChannel}s
 */
public Multimap<Sha256Hash, StoredClientChannel> getChannelMap() {
    lock.lock();
    try {
        return ImmutableMultimap.copyOf(mapChannels);
    } finally {
        lock.unlock();
    }
}
 

private CorefAnnotation(final Symbol docId, final Multimap<Integer, KBPString> idToCASes,
    final Map<KBPString, Integer> CASesToIDs, final Set<KBPString> unannotated) {
  this.docId = checkNotNull(docId);
  this.idToCASes = ImmutableMultimap.copyOf(idToCASes);
  this.CASesToIDs = ImmutableMap.copyOf(CASesToIDs);
  this.unannotated = ImmutableSet.copyOf(unannotated);
  checkConsistency();
}
 

@Deprecated
public HarvesterAnimationStateMachine(ImmutableMap<String, ITimeValue> parameters,
        ImmutableMap<String, IClip> clips, ImmutableList<String> states, ImmutableMap<String, String> transitions,
        String startState) {
    this(parameters, clips, states, ImmutableMultimap.copyOf(
            Multimaps.newSetMultimap(Maps.transformValues(transitions, ImmutableSet::of), Sets::newHashSet)),
            startState);
}
 

/**
 * Get a copy of all {@link StoredClientChannel}s
 */
public Multimap<Sha256Hash, StoredClientChannel> getChannelMap() {
    lock.lock();
    try {
        return ImmutableMultimap.copyOf(mapChannels);
    } finally {
        lock.unlock();
    }
}
 

public ClusterState(
        Set<String> activeNodes,
        Map<String, Long> assignedBytes,
        Multimap<Distribution, BucketAssignment> distributionAssignments,
        Map<Distribution, Long> distributionBucketSize)
{
    this.activeNodes = ImmutableSet.copyOf(requireNonNull(activeNodes, "activeNodes is null"));
    this.assignedBytes = ImmutableMap.copyOf(requireNonNull(assignedBytes, "assignedBytes is null"));
    this.distributionAssignments = ImmutableMultimap.copyOf(requireNonNull(distributionAssignments, "distributionAssignments is null"));
    this.distributionBucketSize = ImmutableMap.copyOf(requireNonNull(distributionBucketSize, "distributionBucketSize is null"));
}
 

public SchemaResolutionException(final @NonNull String message, final SourceIdentifier failedSource,
        final Throwable cause, final @NonNull Collection<SourceIdentifier> resolvedSources,
        final @NonNull Multimap<SourceIdentifier, ModuleImport> unsatisfiedImports) {
    super(formatMessage(message, failedSource, resolvedSources, unsatisfiedImports), cause);
    this.failedSource = failedSource;
    this.unsatisfiedImports = ImmutableMultimap.copyOf(unsatisfiedImports);
    this.resolvedSources = ImmutableList.copyOf(resolvedSources);
}
 

private AspectParameters(Multimap<String, String> attributes) {
  this.attributes = ImmutableMultimap.copyOf(attributes);
}
 

private AqueryActionFilter(Builder builder) {
  filterMap = ImmutableMultimap.copyOf(builder.filterMap);
}
 

public UsersState(
    Set<FmsGroup> groups, Set<FmsUser> users, Multimap<String, String> groupMembership) {
    this.groups = ImmutableSet.copyOf(requireNonNull(groups, "groups is null"));
    this.users = ImmutableSet.copyOf(requireNonNull(users, "users is null"));
    this.groupMembership = ImmutableMultimap.copyOf(requireNonNull(groupMembership, "group membership is null"));
}
 

/**
 * @since 2.16
 */
protected Multimap<String, Endpoint> getExtensionProviders() {
	return ImmutableMultimap.copyOf(extensionProviders);
}
 

public ImmutableMultimap<Long, ErrorCase> getErrorsByCode() {
  return ImmutableMultimap.copyOf(errorsByCode);
}
 

/**
 * Return the variable scopes of the given node.
 * 
 * @param node
 * @return
 */
public Multimap<ASTNode, Variable> getVariableScopes(final ASTNode node) {
	variableScopes.clear();
	node.accept(this);
	return ImmutableMultimap.copyOf(variableScopes);
}