Java Code Examples for com.google.common.collect.ImmutableSet.Builder#build()

public Set<PluginMessageListenerRegistration> getIncomingChannelRegistrations(Plugin plugin, String channel) {
    if (plugin == null) {
        throw new IllegalArgumentException("Plugin cannot be null");
    }
    validateChannel(channel);

    synchronized (incomingLock) {
        Set<PluginMessageListenerRegistration> registrations = incomingByPlugin.get(plugin);

        if (registrations != null) {
            Builder<PluginMessageListenerRegistration> builder = ImmutableSet.builder();

            for (PluginMessageListenerRegistration registration : registrations) {
                if (registration.getChannel().equals(channel)) {
                    builder.add(registration);
                }
            }

            return builder.build();
        } else {
            return ImmutableSet.of();
        }
    }
}
 

public Set<String> getIncomingChannels(Plugin plugin) {
    if (plugin == null) {
        throw new IllegalArgumentException("Plugin cannot be null");
    }

    synchronized (incomingLock) {
        Set<PluginMessageListenerRegistration> registrations = incomingByPlugin.get(plugin);

        if (registrations != null) {
            Builder<String> builder = ImmutableSet.builder();

            for (PluginMessageListenerRegistration registration : registrations) {
                builder.add(registration.getChannel());
            }

            return builder.build();
        } else {
            return ImmutableSet.of();
        }
    }
}
 

@Override
public void fromBytes(ByteBuf b){
    trainID = b.readInt();

    int ids = b.readInt();
    PacketBuffer pb = new PacketBuffer(b);
    Builder<UUID> cartIDs = new ImmutableSet.Builder<>();
    for(int i = 0; i < ids; i++) {
        cartIDs.add(pb.readUniqueId());
    }
    this.cartIDs = cartIDs.build();

    int posCount = b.readInt();
    Builder<MCPos> positions = new ImmutableSet.Builder<>();
    for(int i = 0; i < posCount; i++) {
        positions.add(new MCPos(b));
    }
    this.positions = positions.build();
}
 

private Set<String> getPermutationsConditions(ResourceContext context,
    List<String> permutationAxes) {
  Builder<String> setBuilder = ImmutableSet.builder();
  PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle();

  for (String permutationAxis : permutationAxes) {
    String propValue = null;
    try {
      SelectionProperty selProp = oracle.getSelectionProperty(null,
          permutationAxis);
      propValue = selProp.getCurrentValue();
    } catch (BadPropertyValueException e) {
      try {
        ConfigurationProperty confProp = oracle.getConfigurationProperty(permutationAxis);
        propValue = confProp.getValues().get(0);
      } catch (BadPropertyValueException e1) {
        e1.printStackTrace();
      }
    }

    if (propValue != null) {
      setBuilder.add(permutationAxis + ":" + propValue);
    }
  }
  return setBuilder.build();
}
 

@Test
void curatorDiscovery() throws Throwable {
    final List<Endpoint> sampleEndpoints = ZooKeeperTestUtil.sampleEndpoints(3);
    setCuratorXNodeChildren(sampleEndpoints, 0);
    final ZooKeeperDiscoverySpec spec = ZooKeeperDiscoverySpec.builderForCurator(CURATOR_X_SERVICE_NAME)
                                                              .build();
    final ZooKeeperEndpointGroup endpointGroup = endpointGroup(spec);
    await().untilAsserted(() -> assertThat(endpointGroup.endpoints()).hasSameElementsAs(sampleEndpoints));

    // Add two more nodes.
    final List<Endpoint> extraEndpoints = ZooKeeperTestUtil.sampleEndpoints(2);
    setCuratorXNodeChildren(extraEndpoints, 3);

    // Construct the final expected node list.
    final Builder<Endpoint> builder = ImmutableSet.builder();
    builder.addAll(sampleEndpoints).addAll(extraEndpoints);
    try (CloseableZooKeeper zk = zkInstance.connection()) {
        zk.sync(Z_NODE, (rc, path, ctx) -> {}, null);
    }

    final Set<Endpoint> expected = builder.build();
    await().untilAsserted(() -> assertThat(endpointGroup.endpoints()).hasSameElementsAs(expected));
    disconnectZk(endpointGroup);
}
 

/**
 * Attempt to resolve a RIB route down to an interface route.
 *
 * @param rib {@link GenericRib} for which to do the resolution.
 * @param route {@link AbstractRoute} with a next hop IP to be resolved.
 * @return A map (interface name -> last hop IP -> last taken route) for
 * @throws BatfishException if resolution depth is exceeded (high likelihood of a routing loop) OR
 *     an invalid route in the RIB has been encountered.
 */
@VisibleForTesting
Set<FibEntry> resolveRoute(
    GenericRib<? extends AbstractRouteDecorator> rib, AbstractRoute route) {
  ResolutionTreeNode resolutionRoot = ResolutionTreeNode.root(route);
  buildResolutionTree(
      rib,
      route,
      Route.UNSET_ROUTE_NEXT_HOP_IP,
      new HashSet<>(),
      0,
      Prefix.MAX_PREFIX_LENGTH,
      null,
      resolutionRoot);
  Builder<FibEntry> collector = ImmutableSet.builder();
  collectEntries(resolutionRoot, new Stack<>(), collector);
  return collector.build();
}
 

ImmutableNegotiationResult(final ImmutableVariant variant, ImmutableQuality quality, final ImmutableVariant errorVariant, ImmutableAlternatives alternatives) {
	checkArgument(
		(variant==null && quality==null) ||
		(variant!=null && quality!=null),
		"Variant and quality must be simultaneously defined or not (%s <--> %s)",variant,quality);
	checkNotNull(errorVariant,"Error variant cannot be null");
	checkNotNull(alternatives,"Alternatives cannot be null");
	this.variant=variant;
	this.quality=quality;
	this.errorVariant=errorVariant;
	this.alternatives=alternatives;
	Builder<MediaType> mtBuilder=ImmutableSet.<MediaType>builder();
	Builder<CharacterEncoding> ceBuilder=ImmutableSet.<CharacterEncoding>builder();
	Builder<Language> lBuilder=ImmutableSet.<Language>builder();
	for(Alternative alternative:alternatives) {
		addEntityIfPresent(mtBuilder,alternative.type());
		addEntityIfPresent(ceBuilder,alternative.charset());
		addEntityIfPresent(lBuilder,alternative.language());
	}
	this.mediaTypes=mtBuilder.build();
	this.characterEncodings=ceBuilder.build();
	this.languages=lBuilder.build();
}
 

@Override
public ImmutableSet<QName> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
    final Builder<QName> builder = ImmutableSet.builder();
    int tokens = 0;
    for (String keyToken : LIST_KEY_SPLITTER.split(value)) {
        builder.add(StmtContextUtils.parseNodeIdentifier(ctx, keyToken));
        tokens++;
    }

    // Throws NPE on nulls, retains first inserted value, cannot be modified
    final ImmutableSet<QName> ret = builder.build();
    SourceException.throwIf(ret.size() != tokens, ctx.getStatementSourceReference(),
            "Key argument '%s' contains duplicates", value);
    return ret;
}
 

private static ImmutableSet<String> fillBits(final int size) {
    final Builder<String> builder = ImmutableSet.builderWithExpectedSize(size);
    for (int i = 0; i < size; ++i) {
        builder.add(Integer.toHexString(i));
    }
    final ImmutableSet<String> ret = builder.build();
    Assert.assertEquals(size, ret.size());
    return ret;
}
 

public CodecsImpl(final RIBSupport<?, ?, ?, ?> ribSupport) {
    this.ribSupport = requireNonNull(ribSupport);
    final Builder<Class<? extends BindingObject>> acb = ImmutableSet.builder();
    acb.addAll(ATTRIBUTE_CACHEABLES);
    acb.addAll(this.ribSupport.cacheableAttributeObjects());
    this.cacheableAttributes = acb.build();
}
 

protected Set<RunningInstance> getSpots(Set<RegionAndName> regionAndIds) {
   Builder<RunningInstance> builder = ImmutableSet.<RunningInstance> builder();
   Multimap<String, String> regionToSpotIds = transformValues(index(regionAndIds, regionFunction()), nameFunction());
   for (Map.Entry<String, Collection<String>> entry : regionToSpotIds.asMap().entrySet()) {
      String region = entry.getKey();
      Collection<String> spotIds = entry.getValue();
      logger.trace("looking for spots %s in region %s", spotIds, region);
      builder.addAll(transform(
                               client.getSpotInstanceApi().get().describeSpotInstanceRequestsInRegion(region,
                  toArray(spotIds, String.class)), spotConverter));
   }
   return builder.build();
}
 

/** @return all elements in the trie. */
@Nonnull
public Set<T> getAllElements() {
  Builder<T> b = ImmutableSet.builder();
  traverseNodes(node -> b.addAll(node._elements));
  return b.build();
}
 

public SymbolProto(final Class clazz, final boolean hasSequence, final boolean hasArgs, final int kind,
		final boolean doesNotHaveScope, final FacetProto[] possibleFacets, final String omissible,
		final String[] contextKeywords, final int[] parentKinds, final boolean isRemoteContext,
		final boolean isUniqueInContext, final boolean nameUniqueInContext, final ISymbolConstructor constr,
		final IValidator validator, final SymbolSerializer serializer, final String name, final String plugin) {
	super(name, clazz, plugin);
	factory = DescriptionFactory.getFactory(kind);
	this.validator = validator;
	this.serializer = serializer;
	constructor = constr;
	this.isRemoteContext = isRemoteContext;
	this.hasSequence = hasSequence;
	this.isPrimitive = IKeyword.PRIMITIVE.equals(name);
	this.hasArgs = hasArgs;
	this.omissibleFacet = omissible;
	this.isUniqueInContext = isUniqueInContext;
	this.kind = kind;
	this.isVar = ISymbolKind.Variable.KINDS.contains(kind);
	this.hasScope = !doesNotHaveScope;
	if (possibleFacets != null) {
		final Builder<String> builder = ImmutableSet.builder();
		this.possibleFacets = GamaMapFactory.createUnordered();
		for (final FacetProto f : possibleFacets) {
			this.possibleFacets.put(f.name, f);
			f.setOwner(getTitle());
			if (!f.optional) {
				builder.add(f.name);
			}
		}
		mandatoryFacets = builder.build();
	} else {
		this.possibleFacets = null;
		mandatoryFacets = null;
	}
	this.contextKeywords = ImmutableSet.copyOf(contextKeywords);
	Arrays.fill(this.contextKinds, false);
	for (final int i : parentKinds) {
		contextKinds[i] = true;
	}
}
 

public Set<FlowRule> flowtable() {
    JsonNode ents = object.path(ENTRIES);
    if (!ents.isArray()) {

        return ImmutableSet.of();
    }
    ArrayNode entries = (ArrayNode) ents;

    Builder<FlowRule> builder = ImmutableSet.builder();
    entries.forEach(entry -> builder.add(decode(entry, FlowRule.class)));
    return builder.build();
}
 

public Set<ComplexEntityPart> getParts() {
    Builder<ComplexEntityPart> builder = ImmutableSet.builder();

    for (EntityDragonPart part : getHandle().dragonPartArray) {
        builder.add((ComplexEntityPart) part.getBukkitEntity());
    }

    return builder.build();
}
 

static Set<String> toStringSet(ResultSet resultSet) throws SQLException {
  Builder<String> builder = ImmutableSet.builder();
  final List<Ord<String>> columns = columnLabels(resultSet);
  while (resultSet.next()) {
    StringBuilder buf = new StringBuilder();
    for (Ord<String> column : columns) {
      buf.append(column.i == 1 ? "" : "; ").append(column.e).append("=").append(resultSet.getObject(column.i));
    }
    builder.add(buf.toString());
    buf.setLength(0);
  }
  return builder.build();
}
 

public Set<ComplexEntityPart> getParts() {
    Builder<ComplexEntityPart> builder = ImmutableSet.builder();

    for (MultiPartEntityPart part : getHandle().dragonPartArray) {
        builder.add((ComplexEntityPart) part.getBukkitEntity());
    }

    return builder.build();
}
 

private void finishDoStop(CompletableFuture<Void> future) {
    serverChannels.clear();

    if (config.shutdownBlockingTaskExecutorOnStop()) {
        final ScheduledExecutorService executor;
        final ScheduledExecutorService blockingTaskExecutor = config.blockingTaskExecutor();
        if (blockingTaskExecutor instanceof UnstoppableScheduledExecutorService) {
            executor =
                    ((UnstoppableScheduledExecutorService) blockingTaskExecutor).getExecutorService();
        } else {
            executor = blockingTaskExecutor;
        }

        try {
            executor.shutdown();
            while (!executor.isTerminated()) {
                try {
                    executor.awaitTermination(1, TimeUnit.DAYS);
                } catch (InterruptedException ignore) {
                    // Do nothing.
                }
            }
        } catch (Exception e) {
            logger.warn("Failed to shutdown the blockingTaskExecutor: {}", executor, e);
        }
    }

    final Builder<AccessLogWriter> builder = ImmutableSet.builder();
    config.virtualHosts()
          .stream()
          .filter(VirtualHost::shutdownAccessLogWriterOnStop)
          .forEach(virtualHost -> builder.add(virtualHost.accessLogWriter()));
    config.serviceConfigs()
          .stream()
          .filter(ServiceConfig::shutdownAccessLogWriterOnStop)
          .forEach(serviceConfig -> builder.add(serviceConfig.accessLogWriter()));

    final Set<AccessLogWriter> writers = builder.build();
    final List<CompletableFuture<Void>> completionFutures = new ArrayList<>(writers.size());
    writers.forEach(accessLogWriter -> {
        final CompletableFuture<Void> shutdownFuture = accessLogWriter.shutdown();
        shutdownFuture.exceptionally(cause -> {
            logger.warn("Failed to close the {}:", AccessLogWriter.class.getSimpleName(), cause);
            return null;
        });
        completionFutures.add(shutdownFuture);
    });

    CompletableFutures.successfulAsList(completionFutures, cause -> null)
                      .thenRunAsync(() -> future.complete(null), config.startStopExecutor());
}
 

public JSONEncoder(Class<? super T> type, EncoderKey... additionalKeys) {
    Builder<EncoderKey> set = ImmutableSet.builder();
    set.add(new JSONEncoderKey(type));
    set.addAll(Arrays.asList(additionalKeys));
    this.encoderKeys = set.build();
}
 

public JSONEncoder(EncoderKey... keys) {
    Builder<EncoderKey> set = ImmutableSet.builder();
    set.addAll(Arrays.asList(keys));
    this.encoderKeys = set.build();
}