public void testComplexBuilder() { List<Integer> colorElem = asList(0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF); // javac won't compile this without "this.<Integer>" ImmutableSet.Builder<Integer> webSafeColorsBuilder = this.<Integer>builder(); for (Integer red : colorElem) { for (Integer green : colorElem) { for (Integer blue : colorElem) { webSafeColorsBuilder.add((red << 16) + (green << 8) + blue); } } } ImmutableSet<Integer> webSafeColors = webSafeColorsBuilder.build(); assertEquals(216, webSafeColors.size()); Integer[] webSafeColorArray = webSafeColors.toArray(new Integer[webSafeColors.size()]); assertEquals(0x000000, (int) webSafeColorArray[0]); assertEquals(0x000033, (int) webSafeColorArray[1]); assertEquals(0x000066, (int) webSafeColorArray[2]); assertEquals(0x003300, (int) webSafeColorArray[6]); assertEquals(0x330000, (int) webSafeColorArray[36]); ImmutableSet<Integer> addedColor = webSafeColorsBuilder.add(LAST_COLOR_ADDED).build(); assertEquals( "Modifying the builder should not have changed any already built sets", 216, webSafeColors.size()); assertEquals("the new array should be one bigger than webSafeColors", 217, addedColor.size()); Integer[] appendColorArray = addedColor.toArray(new Integer[addedColor.size()]); assertEquals(getComplexBuilderSetLastElement(), (int) appendColorArray[216]); }
private void logHealthChecks() { final ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (HealthCheck healthCheck : healthChecks.build()) { builder.add(healthCheck.getClass().getCanonicalName()); } LOG.debug("health checks = {}", builder.build()); }
final Set<UUID> getPlayers() { ImmutableSet.Builder<UUID> setBuilder = ImmutableSet.builder(); if (pool != null) { try (Jedis rsc = pool.getResource()) { List<String> keys = new ArrayList<>(); for (String i : getServerIds()) { keys.add("proxy:" + i + ":usersOnline"); } if (!keys.isEmpty()) { Set<String> users = rsc.sunion(keys.toArray(new String[keys.size()])); if (users != null && !users.isEmpty()) { for (String user : users) { try { setBuilder = setBuilder.add(UUID.fromString(user)); } catch (IllegalArgumentException ignored) { } } } } } catch (JedisConnectionException e) { // Redis server has disappeared! getLogger() .log( Level.SEVERE, "Unable to get connection from pool - did your Redis server go away?", e); throw new RuntimeException("Unable to get all players online", e); } } return setBuilder.build(); }
private Set<String> getLocalPlayersAsUuidStrings() { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (ProxiedPlayer player : getProxy().getPlayers()) { builder.add(player.getUniqueId().toString()); } return builder.build(); }
private void logManagedObjects() { final ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (Object bean : lifeCycle.getBeans()) { builder.add(bean.getClass().getCanonicalName()); } LOG.debug("managed objects = {}", builder.build()); }
private void logProviders() { final ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (Class<?> klass : config.getClasses()) { if (klass.isAnnotationPresent(Provider.class)) { builder.add(klass.getCanonicalName()); } } for (Object o : config.getSingletons()) { if (o.getClass().isAnnotationPresent(Provider.class)) { builder.add(o.getClass().getCanonicalName()); } } LOG.debug("providers = {}", builder.build()); }
public Set<UUID> getPlayersOnProxy(String server) { checkArgument(getServerIds().contains(server), server + " is not a valid proxy ID"); try (Jedis jedis = pool.getResource()) { Set<String> users = jedis.smembers("proxy:" + server + ":usersOnline"); ImmutableSet.Builder<UUID> builder = ImmutableSet.builder(); for (String user : users) { builder.add(UUID.fromString(user)); } return builder.build(); } }
final Set<UUID> getPlayersOnServer(@NonNull String server) { checkArgument(getProxy().getServers().containsKey(server), "server does not exist"); Collection<String> asStrings = (Collection<String>) getServerPlayersScript.eval( ImmutableList.<String>of(), ImmutableList.<String>of(server)); ImmutableSet.Builder<UUID> builder = ImmutableSet.builder(); for (String s : asStrings) { builder.add(UUID.fromString(s)); } return builder.build(); }
private Set<TestBean> buildBeans() { ImmutableSet.Builder<TestBean> aBuilder = ImmutableSet.builder(); aBuilder.add( new TestBean("John", "Doe", "blue"), new TestBean("Sally", "Smith", "red"), new TestBean("Abe", "Lincoln", "black"), new TestBean("Albus", "Dumbledore", "purple"), new TestBean("Herminoe", "Grainger", "pink")); return aBuilder.build(); }
public void testBuilderAddHandlesNullsCorrectly() { ImmutableSet.Builder<String> builder = this.<String>builder(); try { builder.add((String) null); fail("expected NullPointerException"); // COV_NF_LINE } catch (NullPointerException expected) { } builder = this.<String>builder(); try { builder.add((String[]) null); fail("expected NullPointerException"); // COV_NF_LINE } catch (NullPointerException expected) { } builder = this.<String>builder(); try { builder.add("a", (String) null); fail("expected NullPointerException"); // COV_NF_LINE } catch (NullPointerException expected) { } builder = this.<String>builder(); try { builder.add("a", "b", (String) null); fail("expected NullPointerException"); // COV_NF_LINE } catch (NullPointerException expected) { } builder = this.<String>builder(); try { builder.add("a", "b", "c", null); fail("expected NullPointerException"); // COV_NF_LINE } catch (NullPointerException expected) { } builder = this.<String>builder(); try { builder.add("a", "b", null, "c"); fail("expected NullPointerException"); // COV_NF_LINE } catch (NullPointerException expected) { } }
public transient Builder add(Object aobj[]) { super.add(aobj); return this; }
public Builder add(Object obj) { super.add(obj); return this; }
public Builder add(Object paramObject) { super.add(paramObject); return this; }
/** * Adds a {@link Task} instance. * * @param task a {@link Task} */ public void addTask(Task task) { tasks.add(checkNotNull(task)); }
/** * Adds the given health check to the set of health checks exposed on the admin port. * * @param healthCheck a health check */ public void addHealthCheck(HealthCheck healthCheck) { healthChecks.add(checkNotNull(healthCheck)); }
/** * Generates an implementation of the given managed type. * * <p>The generated class will implement/extend the managed type and will: * * <ul> * <li>provide implementations for abstract getters and setters that delegate to model nodes * <li>provide a `toString()` implementation * <li>mix-in implementation of {@link ManagedInstance} * <li>provide a constructor that accepts a {@link ModelElementState}, which will be used to * implement the above. * </ul> * * In case a delegate schema is supplied, the generated class will also have: * * <ul> * <li>a constructor that also takes a delegate instance * <li>methods that call through to the delegate instance * </ul> */ public <T, M extends T, D extends T> Class<? extends M> generate( StructSchema<M> viewSchema, @Nullable StructSchema<D> delegateSchema) { if (delegateSchema != null && Modifier.isAbstract(delegateSchema.getType().getConcreteClass().getModifiers())) { throw new IllegalArgumentException("Delegate type must be null or a non-abstract type"); } ClassWriter visitor = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); ModelType<M> viewType = viewSchema.getType(); StringBuilder generatedTypeNameBuilder = new StringBuilder(viewType.getName()); if (delegateSchema != null) { generatedTypeNameBuilder .append("$BackedBy_") .append(delegateSchema.getType().getName().replaceAll("\\.", "_")); } else { generatedTypeNameBuilder.append("$Impl"); } String generatedTypeName = generatedTypeNameBuilder.toString(); Type generatedType = Type.getType("L" + generatedTypeName.replaceAll("\\.", "/") + ";"); Class<M> viewClass = viewType.getConcreteClass(); Class<?> superclass; final ImmutableSet.Builder<String> interfacesToImplement = ImmutableSet.builder(); final ImmutableSet.Builder<Class<?>> typesToDelegate = ImmutableSet.builder(); typesToDelegate.add(viewClass); interfacesToImplement.add(MANAGED_INSTANCE_TYPE); if (viewClass.isInterface()) { superclass = Object.class; interfacesToImplement.add(Type.getInternalName(viewClass)); } else { superclass = viewClass; } // TODO:LPTR This should be removed once BinaryContainer is a ModelMap // We need to also implement all the interfaces of the delegate type because otherwise // BinaryContainer won't recognize managed binaries as BinarySpecInternal if (delegateSchema != null) { ModelSchemaUtils.walkTypeHierarchy( delegateSchema.getType().getConcreteClass(), new ModelSchemaUtils.TypeVisitor<D>() { @Override public void visitType(Class<? super D> type) { if (type.isInterface()) { typesToDelegate.add(type); interfacesToImplement.add(Type.getInternalName(type)); } } }); } generateProxyClass( visitor, viewSchema, delegateSchema, interfacesToImplement.build(), typesToDelegate.build(), generatedType, Type.getType(superclass)); ClassLoader targetClassLoader = viewClass.getClassLoader(); if (delegateSchema != null) { // TODO - remove this once the above is removed try { viewClass.getClassLoader().loadClass(delegateSchema.getType().getConcreteClass().getName()); } catch (ClassNotFoundException e) { // Delegate class is not visible to managed view type -> view type is more general than // delegate type, so use the delegate classloader instead targetClassLoader = delegateSchema.getType().getConcreteClass().getClassLoader(); } } return defineClass(visitor, targetClassLoader, generatedTypeName); }
/** * Adds each element of {@code elements} to the {@code ImmutableSortedSet}, ignoring duplicate * elements (only the first duplicate element is added). * * @param elements the elements to add * @return this {@code Builder} object * @throws NullPointerException if {@code elements} contains a null element */ @Override public Builder<E> add(E... elements) { super.add(elements); return this; }
public Builder add(Object... paramVarArgs) { super.add(paramVarArgs); return this; }
/** * Adds {@code element} to the {@code ImmutableSortedSet}. If the {@code ImmutableSortedSet} * already contains {@code element}, then {@code add} has no effect. (only the previously added * element is retained). * * @param element the element to add * @return this {@code Builder} object * @throws NullPointerException if {@code element} is null */ @Override public Builder<E> add(E element) { super.add(element); return this; }