Java Sets.newHashSetWithExpectedSize方法代码示例

import com.google.common.collect.Sets; //导入方法依赖的package包/类
/**
 * Reads the list of components from the TOC component.
 * @return set of components found in the TOC
 */
protected static Set<Component> readTOC(Descriptor descriptor) throws IOException
{
    List<String> componentNames = readLines(descriptor.filenameFor(Component.TOC), descriptor.getConfiguration());
    Set<Component> components = Sets.newHashSetWithExpectedSize(componentNames.size());
    for (String componentName : componentNames)
    {
        logger.info("Checking for the existence of [" + componentName + "]");
        Component component = new Component(Component.Type.fromRepresentation(componentName), componentName);
        if (!HadoopFileUtils.exists(descriptor.filenameFor(component), descriptor.getConfiguration()))
            logger.error("Missing component: {}", descriptor.filenameFor(component));
        else
            components.add(component);
    }

    return components;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
public void testBulkGetReturnsSorted() {
  for (Striped<?> striped : allImplementations()) {
    Map<Object, Integer> indexByLock = Maps.newHashMap();
    for (int i = 0; i < striped.size(); i++) {
      indexByLock.put(striped.getAt(i), i);
    }

    // ensure that bulkGet returns locks in monotonically increasing order
    for (int objectsNum = 1; objectsNum <= striped.size() * 2; objectsNum++) {
      Set<Object> objects = Sets.newHashSetWithExpectedSize(objectsNum);
      for (int i = 0; i < objectsNum; i++) {
        objects.add(new Object());
      }

      Iterable<?> locks = striped.bulkGet(objects);
      assertTrue(Ordering.natural().onResultOf(Functions.forMap(indexByLock)).isOrdered(locks));

      // check idempotency
      Iterable<?> locks2 = striped.bulkGet(objects);
      assertEquals(Lists.newArrayList(locks), Lists.newArrayList(locks2));
    }
  }
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
protected List<Recipe> getRecipes(FeatureWrapper feature, Collection<Pickle> pickles) {
	int pickleCount = pickles.size();
	ArrayList<Recipe> recipes = Lists.newArrayListWithExpectedSize(pickleCount);
	Set<Integer> pickleLines = Sets.newHashSetWithExpectedSize(pickleCount);

	RangeMap<Integer, ScenarioDefinition> rangeMap = getRangeMap(feature);
	for (Pickle pickle : pickles) {
		List<PickleLocation> locations = pickle.getLocations();
		for (PickleLocation location : locations) {
			int line = location.getLine();
			if (!pickleLines.contains(line)) {
				pickleLines.add(line);
				Range<Integer> range = Range.singleton(line);
				RangeMap<Integer, ScenarioDefinition> subRangeMap = rangeMap.subRangeMap(range);
				Map<Range<Integer>, ScenarioDefinition> asMap = subRangeMap.asMapOfRanges();
				checkState(1 == asMap.size(), "no single range found encompassing PickleLocation %s", location);
				ScenarioDefinition definition = Iterables.getOnlyElement(asMap.values());
				Recipe recipe = new Recipe(feature, pickle, location, definition);
				recipes.add(recipe);
			}
		}
	}
	return recipes;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
/**
 * Gets initial volume failure information for all volumes that failed
 * immediately at startup.  The method works by determining the set difference
 * between all configured storage locations and the actual storage locations in
 * use after attempting to put all of them into service.
 *
 * @return each storage location that has failed
 */
private static List<VolumeFailureInfo> getInitialVolumeFailureInfos(
    Collection<StorageLocation> dataLocations, DataStorage storage) {
  Set<String> failedLocationSet = Sets.newHashSetWithExpectedSize(
      dataLocations.size());
  for (StorageLocation sl: dataLocations) {
    failedLocationSet.add(sl.getFile().getAbsolutePath());
  }
  for (Iterator<Storage.StorageDirectory> it = storage.dirIterator();
       it.hasNext(); ) {
    Storage.StorageDirectory sd = it.next();
    failedLocationSet.remove(sd.getRoot().getAbsolutePath());
  }
  List<VolumeFailureInfo> volumeFailureInfos = Lists.newArrayListWithCapacity(
      failedLocationSet.size());
  long failureDate = Time.now();
  for (String failedStorageLocation: failedLocationSet) {
    volumeFailureInfos.add(new VolumeFailureInfo(failedStorageLocation,
        failureDate));
  }
  return volumeFailureInfos;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
public Set<? extends Task> getDependencies(Task task) {
    Set<Task> tasks = Sets.newHashSetWithExpectedSize(taskDependencyNames.size());
    for (String dependedOnTaskName : taskDependencyNames) {
        Task dependency = task.getProject().getTasks().findByName(dependedOnTaskName);
        if (dependency == null) {
            throw new UnknownTaskException(String.format("Imported Ant target '%s' depends on target or task '%s' which does not exist", task.getName(), dependedOnTaskName));
        }
        tasks.add(dependency);
    }
    return tasks;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
static void checkExactMatches(CharMatcher m, char[] chars) {
  Set<Character> positive = Sets.newHashSetWithExpectedSize(chars.length);
  for (char c : chars) {
    positive.add(c);
  }
  for (int c = 0; c <= Character.MAX_VALUE; c++) {
    assertFalse(positive.contains(new Character((char) c)) ^ m.matches((char) c));
  }
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
private static void ensureNoDuplicateColumnNames(List<String> fieldNames) throws ValidationException {
  final HashSet<String> fieldHashSet = Sets.newHashSetWithExpectedSize(fieldNames.size());
  for(String field : fieldNames) {
    if (fieldHashSet.contains(field.toLowerCase())) {
      throw new ValidationException(String.format("Duplicate column name [%s]", field));
    }
    fieldHashSet.add(field.toLowerCase());
  }
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
/**
 * Constructor.
 * @param scopePatroon een patroon
 */
CachedScopePatroon(final ScopePatroon scopePatroon) {
    this.scopePatroon = scopePatroon;

    elementAttribuutSet = Sets.newHashSetWithExpectedSize(scopePatroon.getScopePatroonElementSet().size());
    for (final ScopePatroonElement scopePatroonElement : scopePatroon.getScopePatroonElementSet()) {
        elementAttribuutSet.add(scopePatroonElement.getElementId());
    }
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
@Test
public void testMultipleGivenRegex() throws NoSuchMethodException {
	MultipleGivenBean source = new MultipleGivenBean();
	ClassPathXmlApplicationContext context = getContext(source);
	process(context, source);

	MultipleGivenBean steps = context.getBean(MultipleGivenBean.class);
	Class<?> wrapped = AopUtils.getTargetClass(steps);
	Method method = wrapped.getMethod("doSomething");

	Map<String, StepImplementation> givenBeanIndex = context.getBeansOfType(StepImplementation.class);
	Collection<StepImplementation> givens = givenBeanIndex.values();

	Set<String> matches = Sets.newHashSetWithExpectedSize(2);
	for (StepImplementation given : givens) {
		Method givenMethod = given.getMethod();
		if (givenMethod.equals(method)) {
			Pattern pattern = given.getPattern();
			String regex = pattern.pattern();
			matches.add(regex);
		}
	}

	int count = matches.size();
	assertEquals(count, 2, "wrong number of GivenStep objects registered for MultipleGivenBean.getMartinis()");

	Set<String> expected = Sets.newHashSet(
		"this is regular expression one", "this is regular expression two");
	assertEquals(matches, expected, "Steps contain wrong regex Pattern objects");
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
private Map<LinkKey, MplsLabel> assignMplsLabel(MplsPathIntent intent) {
    // TODO: do it better... Suggestions?
    Set<LinkKey> linkRequest = Sets.newHashSetWithExpectedSize(intent.path()
            .links().size() - 2);
    for (int i = 1; i <= intent.path().links().size() - 2; i++) {
        LinkKey link = linkKey(intent.path().links().get(i));
        linkRequest.add(link);
        // add the inverse link. I want that the label is reserved both for
        // the direct and inverse link
        linkRequest.add(linkKey(link.dst(), link.src()));
    }

    Map<LinkKey, MplsLabel> labels = findMplsLabels(linkRequest);
    if (labels.isEmpty()) {
        return Collections.emptyMap();
    }

    // for short term solution: same label is used for both directions
    // TODO: introduce the concept of Tx and Rx resources of a port
    Set<Resource> resources = labels.entrySet().stream()
            .flatMap(x -> Stream.of(
                    Resources.discrete(x.getKey().src().deviceId(), x.getKey().src().port(), x.getValue())
                            .resource(),
                    Resources.discrete(x.getKey().dst().deviceId(), x.getKey().dst().port(), x.getValue())
                            .resource()
            ))
            .collect(Collectors.toSet());
    List<ResourceAllocation> allocations =
            resourceService.allocate(intent.id(), ImmutableList.copyOf(resources));
    if (allocations.isEmpty()) {
        Collections.emptyMap();
    }

    return labels;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
private Map<LinkKey, VlanId> assignVlanId(PathCompilerCreateFlow creator, PathIntent intent) {
    Set<LinkKey> linkRequest =
            Sets.newHashSetWithExpectedSize(intent.path()
                    .links().size() - 2);
    for (int i = 1; i <= intent.path().links().size() - 2; i++) {
        LinkKey link = linkKey(intent.path().links().get(i));
        linkRequest.add(link);
        // add the inverse link. I want that the VLANID is reserved both for
        // the direct and inverse link
        linkRequest.add(linkKey(link.dst(), link.src()));
    }

    Map<LinkKey, VlanId> vlanIds = findVlanIds(creator, linkRequest);
    if (vlanIds.isEmpty()) {
        creator.log().warn("No VLAN IDs available");
        return Collections.emptyMap();
    }

    //same VLANID is used for both directions
    Set<Resource> resources = vlanIds.entrySet().stream()
            .flatMap(x -> Stream.of(
                    Resources.discrete(x.getKey().src().deviceId(), x.getKey().src().port(), x.getValue())
                            .resource(),
                    Resources.discrete(x.getKey().dst().deviceId(), x.getKey().dst().port(), x.getValue())
                            .resource()
            ))
            .collect(Collectors.toSet());
    List<ResourceAllocation> allocations =
            creator.resourceService().allocate(intent.id(), ImmutableList.copyOf(resources));
    if (allocations.isEmpty()) {
        return Collections.emptyMap();
    }

    return vlanIds;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
private Map<LinkKey, MplsLabel> assignMplsLabel(PathCompilerCreateFlow creator, PathIntent intent) {
            Set<LinkKey> linkRequest =
            Sets.newHashSetWithExpectedSize(intent.path()
                    .links().size() - 2);
    for (int i = 1; i <= intent.path().links().size() - 2; i++) {
        LinkKey link = linkKey(intent.path().links().get(i));
        linkRequest.add(link);
        // add the inverse link. I want that the VLANID is reserved both for
        // the direct and inverse link
        linkRequest.add(linkKey(link.dst(), link.src()));
    }

    Map<LinkKey, MplsLabel> labels = findMplsLabels(creator, linkRequest);
    if (labels.isEmpty()) {
        throw new IntentCompilationException("No available MPLS Label");
    }

    // for short term solution: same label is used for both directions
    // TODO: introduce the concept of Tx and Rx resources of a port
    Set<Resource> resources = labels.entrySet().stream()
            .flatMap(x -> Stream.of(
                    Resources.discrete(x.getKey().src().deviceId(), x.getKey().src().port(), x.getValue())
                            .resource(),
                    Resources.discrete(x.getKey().dst().deviceId(), x.getKey().dst().port(), x.getValue())
                            .resource()
            ))
            .collect(Collectors.toSet());
    List<ResourceAllocation> allocations =
            creator.resourceService().allocate(intent.id(), ImmutableList.copyOf(resources));
    if (allocations.isEmpty()) {
        return Collections.emptyMap();
    }

    return labels;
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
/**
 * Find available TributarySlots across path.
 *
 * @param intent
 * @param path path in OTU topology
 * @return Map of Linkey and Set of available TributarySlots on its ports
 */
private Map<LinkKey, Set<TributarySlot>> findAvailableTributarySlots(OpticalOduIntent intent, Path path) {
    Set<LinkKey> linkRequest = Sets.newHashSetWithExpectedSize(path.links().size());
    for (int i = 0; i < path.links().size(); i++) {
        LinkKey link = linkKey(path.links().get(i));
        linkRequest.add(link);
    }

    return findTributarySlots(intent, linkRequest);
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
private Undirected(BaseGraph<N> graph) {
  super(graph);
  this.visitedNodes = Sets.newHashSetWithExpectedSize(graph.nodes().size());
}
 

import com.google.common.collect.Sets; //导入方法依赖的package包/类
private Set<DisjointPath> edgeToEdgePathsDisjoint(EdgeLink srcLink, EdgeLink dstLink) {
    Set<DisjointPath> endToEndPaths = Sets.newHashSetWithExpectedSize(1);
    endToEndPaths.add(edgeToEdgePathD(srcLink, dstLink, null));
    return endToEndPaths;
}