/** as {@link #addAll(Collection)} but fluent style and permitting null */ public MutableSet<V> putAll(Iterable<? extends V> setToAdd) { if (setToAdd!=null) addAll(setToAdd); return this; }
public Builder<V> addAll(Iterable<? extends V> iterable) { if (iterable instanceof Collection) { result.addAll((Collection<? extends V>) iterable); } else { for (V v : iterable) { result.add(v); } } return this; }
@Override public Iterable<URL> getResources(String name) { MutableSet<URL> result = MutableSet.<URL>of(); for (BrooklynClassLoadingContext target : primaries) { result.addAll(target.getResources(name)); } for (BrooklynClassLoadingContext target : secondaries) { result.addAll(target.getResources(name)); } return result; }
@Override protected Set<Object> merge(boolean unmodifiable, Iterable<?>... sets) { MutableSet<Object> result = MutableSet.of(); for (Iterable<?> set: sets) result.addAll(set); if (unmodifiable) return result.asUnmodifiable(); return result; }
private void addReferencedObjects(DeltaCollector deltaCollector) { MutableSet<BrooklynObject> referencedObjects = MutableSet.of(); // collect references for (Entity entity : deltaCollector.entities) { // FIXME How to let the policy/location tell us about changes? Don't do this every time! for (Location location : entity.getLocations()) { Collection<Location> findLocationsInHierarchy = TreeUtils.findLocationsInHierarchy(location); referencedObjects.addAll(findLocationsInHierarchy); } if (persistPoliciesEnabled) { referencedObjects.addAll(entity.policies()); } if (persistEnrichersEnabled) { referencedObjects.addAll(entity.enrichers()); } if (persistFeedsEnabled) { referencedObjects.addAll(((EntityInternal)entity).feeds().getFeeds()); } } for (BrooklynObject instance : referencedObjects) { deltaCollector.addIfNotRemoved(instance); } }
@Test public void testReadAManifest() throws Exception { Enumeration<URL> manifests = this.getClass().getClassLoader().getResources("META-INF/MANIFEST.MF"); log.info("Bundles and exported packages:"); MutableSet<String> allPackages = MutableSet.of(); while (manifests.hasMoreElements()) { ManifestHelper mf = ManifestHelper.forManifestContents(Streams.readFullyStringAndClose(manifests.nextElement().openStream())); List<String> mfPackages = mf.getExportedPackages(); log.info(" " + mf.getSymbolicNameVersion() + ": " + mfPackages); allPackages.addAll(mfPackages); } log.info("Total export package count: " + allPackages.size()); Assert.assertTrue(allPackages.size() > 20, "did not find enough packages"); // probably much larger Assert.assertTrue(allPackages.contains(EmbeddedFelixFramework.class.getPackage().getName())); }
@SuppressWarnings("deprecation") protected Set<ConfigKey<?>> findKeys(Predicate<? super ConfigKey<?>> filter, KeyFindingMode mode) { MutableSet<ConfigKey<?>> result = MutableSet.of(); if (mode==KeyFindingMode.DECLARED_OR_PRESENT) { result.addAll( Iterables.filter(getKeysAtContainer(getContainer()), filter) ); } for (ConfigKey<?> k: Iterables.filter(ownConfig.keySet(), filter)) { if (result.contains(k)) continue; if (mode!=KeyFindingMode.PRESENT_NOT_RESOLVED) { ConfigKey<?> k2 = getKeyAtContainer(getContainer(), k); if (k2!=null) k = k2; } result.add(k); } // due to set semantics local should be added first, it prevents equal items from parent from being added on top if (getParent()!=null) { // now take from runtime parents, but filtered Set<ConfigKey<?>> inherited; switch (mode) { case DECLARED_OR_PRESENT: inherited = getParentInternal().config().getInternalConfigMap().findKeysDeclared(filter); break; case PRESENT_AND_RESOLVED: inherited = getParentInternal().config().getInternalConfigMap().findKeysPresent(filter); break; case PRESENT_NOT_RESOLVED: inherited = getParentInternal().config().getInternalConfigMap().findKeys(filter); break; default: throw new IllegalStateException("Unsupported key finding mode: "+mode); } // TODO due to recursive nature we call this N times for the Nth level ancestor result.addAll( filterOutRuntimeNotReinherited(inherited) ); } return result; }