public Set<String> getColumns() { Set<String> fields = Sets.newHashSet(dimensions); fields.addAll(metrics); return fields; }
private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) { Set<Method> set = Sets.newHashSet(); for (Method m : interfaceType.getMethods()) { if (declaresInterruptedEx(m)) { set.add(m); } } return set; }
private Currency preJava7FreshCurrency() { for (Set<Locale> uselessLocales = Sets.newHashSet(); ; ) { Locale locale = generateLocale(); if (uselessLocales.contains(locale)) { // exhausted all locales return Currency.getInstance(Locale.US); } try { return Currency.getInstance(locale); } catch (IllegalArgumentException e) { uselessLocales.add(locale); } } }
public Map<TblColRef, Set<CubeInstance>> getUsedNonDimCols(String modelName, String project) { Map<TblColRef, Set<CubeInstance>> ret = Maps.newHashMap(); List<CubeInstance> cubeInstances = cubeService.listAllCubes(null, project, modelName, true); for (CubeInstance cubeInstance : cubeInstances) { CubeDesc cubeDesc = cubeInstance.getDescriptor(); Set<TblColRef> tblColRefs = Sets.newHashSet(cubeDesc.listAllColumns());//make a copy tblColRefs.removeAll(cubeDesc.listDimensionColumnsIncludingDerived()); for (TblColRef tblColRef : tblColRefs) { if (ret.containsKey(tblColRef)) { ret.get(tblColRef).add(cubeInstance); } else { Set<CubeInstance> set = Sets.newHashSet(cubeInstance); ret.put(tblColRef, set); } } } return ret; }
/** * Creates a new {@link ParametersAction} that contains all the parameters in this action * with the overrides / new values given as parameters. * @return New {@link ParametersAction}. The result may contain null {@link ParameterValue}s */ @Nonnull public ParametersAction createUpdated(Collection<? extends ParameterValue> overrides) { if(overrides == null) { ParametersAction parametersAction = new ParametersAction(parameters); parametersAction.safeParameters = this.safeParameters; return parametersAction; } List<ParameterValue> combinedParameters = Lists.<ParameterValue>newArrayList(overrides); Set<String> names = newHashSet(); for(ParameterValue v : overrides) { if (v == null) continue; names.add(v.getName()); } for (ParameterValue v : parameters) { if (v == null) continue; if (!names.contains(v.getName())) { combinedParameters.add(v); } } return new ParametersAction(combinedParameters, this.safeParameters); }
@Test public void testPartitionHashes() { assertEquals(8, idManager.getPartitionBound()); Set<Long> hashs = Sets.newHashSet(); for (long i=1;i<idManager.getPartitionBound()*2;i++) hashs.add(idManager.getPartitionHashForId(i)); assertTrue(hashs.size()>idManager.getPartitionBound()/2); assertNotEquals(idManager.getPartitionHashForId(101),idManager.getPartitionHashForId(102)); }
@Test public void removeLongTimeDisappearFromCache(){ INimbus iNimbus = new TestUtilsForBlacklistScheduler.INimbusTest(); topoMap.put(topo1.getId(), topo1); cached.add("sup-1"); cached.add("sup-2"); Assert.assertEquals(cached,bs.cachedSupervisors.keySet()); cluster = new Cluster(iNimbus, resourceMetrics, supMap, new HashMap<String, SchedulerAssignmentImpl>(), topologies, config); bs.schedule(topologies,cluster); bs.schedule(topologies, cluster); Set<Integer> cachedPorts = Sets.newHashSet(1, 2, 3); Assert.assertEquals(cachedPorts, bs.cachedSupervisors.get("sup-0"));
public static <T> T checkSame(Iterator<T> iterator) { Set<T> values = Sets.newHashSet(); while (iterator.hasNext()) { T element = iterator.next(); values.add(element); } if (values.size() > 1) { throw new IllegalStateException("more than one distinct values exist in the collection:" + values); } return values.iterator().next(); } }
private Set<EventHandlerInfo> selectEventHandlers(Class<? extends Event> eventType, EntityRef entity) { Set<EventHandlerInfo> result = Sets.newHashSet(); result.addAll(generalHandlers.get(eventType)); SetMultimap<Class<? extends Component>, EventHandlerInfo> handlers = componentSpecificHandlers.get(eventType); if (handlers == null) { return result; } for (Class<? extends Component> compClass : handlers.keySet()) { if (entity.hasComponent(compClass)) { for (EventHandlerInfo eventHandler : handlers.get(compClass)) { if (eventHandler.isValidFor(entity)) { result.add(eventHandler); } } } } return result; }
protected Set<Class<?>> build(Class<?> concreteClass) { List<Class<?>> parents = Lists.newLinkedList(); Set<Class<?>> classes = Sets.newHashSet(); parents.add(concreteClass); while (!parents.isEmpty()) { Class<?> clazz = parents.remove(0); classes.add(clazz); Class<?> parent = clazz.getSuperclass(); if (parent != null) { parents.add(parent); } Collections.addAll(parents, clazz.getInterfaces()); } return classes; }
public static RawNetFlowV9Packet parsePacketShallow(ByteBuf bb) { final ByteBuf buf = bb.duplicate(); final int dataLength = buf.readableBytes(); final NetFlowV9Header header = parseHeader(buf); final Map<Integer, byte[]> allTemplates = Maps.newHashMap(); Map.Entry<Integer, byte[]> optTemplate = null; final Set<Integer> usedTemplates = Sets.newHashSet(); while (buf.isReadable()) { buf.markReaderIndex(); int flowSetId = buf.readUnsignedShort(); if (flowSetId == 0) { final List<Map.Entry<Integer, byte[]>> templates = parseTemplatesShallow(buf); for (Map.Entry<Integer, byte[]> t : templates) { allTemplates.put(t.getKey(), t.getValue()); } } else if (flowSetId == 1) { optTemplate = parseOptionTemplateShallow(buf); } else { buf.resetReaderIndex(); usedTemplates.add(parseRecordShallow(buf)); } } return RawNetFlowV9Packet.create(header, dataLength, allTemplates, optTemplate, usedTemplates); } }
public Set<ClientMetaInfo> aliveSubjectByAppCode(String appCode) { final Map<ClientMetaInfo, Long> clients = allSubject.get(appCode); if (clients == null || clients.isEmpty()) { return Collections.emptySet(); } final long now = System.currentTimeMillis(); final Set<ClientMetaInfo> result = Sets.newHashSet(); for (Map.Entry<ClientMetaInfo, Long> entry : clients.entrySet()) { if (entry.getValue() != null && now - entry.getValue() < EXPIRE_TIME_MS) { result.add(entry.getKey()); } } return result; }
public static ClassLoader createUDFClassLoader(URLClassLoader loader, String[] newPaths) { final Set<URL> curPathsSet = Sets.newHashSet(loader.getURLs()); final List<URL> curPaths = Lists.newArrayList(curPathsSet); for (String onestr : newPaths) { final URL oneurl = urlFromPathString(onestr); if (oneurl != null && !curPathsSet.contains(oneurl)) { curPaths.add(oneurl); } } return new UDFClassLoader(curPaths.toArray(new URL[0]), loader); }
@Test public void testGetRequiredColumns() { SelectorDimFilter selectorDimFilter = new SelectorDimFilter("abc", "d", null); Assert.assertEquals(selectorDimFilter.getRequiredColumns(), Sets.newHashSet("abc")); } }
@Test public void testFragmentSearch() { Druids.SearchQueryBuilder builder = testBuilder(); Map<String, Set<String>> expectedResults = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); SearchQuery searchQuery; searchQuery = builder.fragments(Arrays.asList("auto", "ve")).build(); expectedResults.put(qualityDimension, Sets.newHashSet("automotive", "AutoMotive")); checkSearchQuery(searchQuery, expectedResults); searchQuery = builder.fragments(Arrays.asList("auto", "ve"), true).build(); expectedResults.put(qualityDimension, Sets.newHashSet("automotive")); checkSearchQuery(searchQuery, expectedResults); }
public void testPowerSetContents() { ImmutableSet<Integer> elements = ImmutableSet.of(1, 2, 3); Set<Set<Integer>> powerSet = powerSet(elements); assertEquals(8, powerSet.size()); assertEquals(4 * 1 + 4 * 2 + 4 * 3, powerSet.hashCode()); Set<Set<Integer>> expected = newHashSet(); expected.add(ImmutableSet.<Integer>of()); expected.add(ImmutableSet.of(1)); expected.add(ImmutableSet.of(2)); expected.add(ImmutableSet.of(3)); expected.add(ImmutableSet.of(1, 2)); expected.add(ImmutableSet.of(1, 3)); expected.add(ImmutableSet.of(2, 3)); expected.add(ImmutableSet.of(1, 2, 3)); Set<Set<Integer>> almostPowerSet = newHashSet(expected); almostPowerSet.remove(ImmutableSet.of(1, 2, 3)); almostPowerSet.add(ImmutableSet.of(1, 2, 4)); new EqualsTester() .addEqualityGroup(expected, powerSet) .addEqualityGroup(ImmutableSet.of(1, 2, 3)) .addEqualityGroup(almostPowerSet) .testEquals(); for (Set<Integer> subset : expected) { assertTrue(powerSet.contains(subset)); } assertFalse(powerSet.contains(ImmutableSet.of(1, 2, 4))); assertFalse(powerSet.contains(singleton(null))); assertFalse(powerSet.contains(null)); assertFalse(powerSet.contains((Object) "notASet")); }
private Set<String> getRequiredConfigListHelper(Set<JobTemplate> alreadyLoadedTemplates) throws SpecNotFoundException, TemplateException { Set<String> requiredConfigs = Sets.newHashSet(getLocallyRequiredConfigList()); for (JobTemplate template : this.superTemplates) { if (!alreadyLoadedTemplates.contains(template)) { alreadyLoadedTemplates.add(template); requiredConfigs.addAll(template instanceof InheritingJobTemplate ? ((InheritingJobTemplate) template).getRequiredConfigListHelper(alreadyLoadedTemplates) : template.getRequiredConfigList()); } } return requiredConfigs; }
/** * */ @Test public void testHashSetModification() { GridBinaryTestClasses.TestObjectContainer obj = new GridBinaryTestClasses.TestObjectContainer(); obj.foo = Sets.newHashSet("a", "b", "c"); BinaryObjectBuilderImpl mutObj = wrap(obj); Set<String> set = mutObj.getField("foo"); set.remove("b"); set.add("!"); assertEquals(Sets.newHashSet("a", "!", "c"), set); assertTrue(set.contains("a")); assertTrue(set.contains("!")); GridBinaryTestClasses.TestObjectContainer res = mutObj.build().deserialize(); assertTrue(res.foo instanceof HashSet); assertEquals(Sets.newHashSet("a", "!", "c"), res.foo); }
@Test public void testCreateSplatted() { List<Integer> firstList = Arrays.asList(1, 2, 5, 7, 9, 10, 20); List<Integer> secondList = Arrays.asList(1, 2, 5, 8, 9); Set<Integer> mergedLists = new HashSet<>(); mergedLists.addAll(firstList); mergedLists.addAll(secondList); ArrayList<Iterable<Integer>> iterators = new ArrayList<>(); iterators.add(firstList); iterators.add(secondList); CombiningIterable<Integer> actualIterable = CombiningIterable.createSplatted( iterators, Ordering.natural() ); Assert.assertEquals(mergedLists.size(), Iterables.size(actualIterable)); Set actualHashset = Sets.newHashSet(actualIterable); Assert.assertEquals(actualHashset, mergedLists); } }
@Override protected Set<String> create(String[] elements) { Set<String> set = Sets.newHashSet(elements); Set<String> other = Sets.newHashSet("wz", "xq"); set.addAll(other); other.add("pq"); return Sets.difference(set, other); } })