com.google.common.collect.Sets#newIdentityHashSet ( )源码实例Demo

@Override
public Set<? extends Value> getInputs() {
    if (compute != null) {
        final Set<Value> inputs = Sets.newIdentityHashSet();
        compute.visitNode(new OperatorTreeVisitor() {
            @Override
            public void visit(Object arg) {
                if (arg instanceof Value) {
                    inputs.add((Value) arg);
                }
            }
        });
        inputs.addAll(before);
        return inputs;
    } else {
        return before;
    }
}
 

@Override
public EntitySet merge(Collection<? extends Entity> entities) {
    checkNotNullArgument(entities, "entity collection is null");

    List<Entity> managedList = new ArrayList<>(entities.size());
    disableListeners = true;
    try {
        Set<Entity> merged = Sets.newIdentityHashSet();

        for (Entity entity : entities) {
            Entity managed = internalMerge(entity, merged, true);
            managedList.add(managed);
        }
    } finally {
        disableListeners = false;
    }
    return EntitySet.of(managedList);
}
 

public SubstitutionVisitor(RelNode target_, RelNode query_, ImmutableList<UnifyRule> rules,
        RelBuilderFactory relBuilderFactory) {
    this.cluster = target_.getCluster();
    final RexExecutor executor = Util.first(cluster.getPlanner().getExecutor(), RexUtil.EXECUTOR);
    final RelOptPredicateList predicates = RelOptPredicateList.EMPTY;
    this.simplify = new RexSimplify(cluster.getRexBuilder(), predicates, executor);
    this.rules = rules;
    this.query = Holder.of(MutableRels.toMutable(query_));
    this.target = MutableRels.toMutable(target_);
    this.relBuilder = relBuilderFactory.create(cluster, null);
    final Set<MutableRel> parents = Sets.newIdentityHashSet();
    final List<MutableRel> allNodes = new ArrayList<>();
    final MutableRelVisitor visitor = new MutableRelVisitor() {
        @Override
        public void visit(MutableRel node) {
            parents.add(node.getParent());
            allNodes.add(node);
            super.visit(node);
        }
    };
    visitor.go(target);

    // Populate the list of leaves in the tree under "target".
    // Leaves are all nodes that are not parents.
    // For determinism, it is important that the list is in scan order.
    allNodes.removeAll(parents);
    targetLeaves = ImmutableList.copyOf(allNodes);

    allNodes.clear();
    parents.clear();
    visitor.go(query);
    allNodes.removeAll(parents);
    queryLeaves = ImmutableList.copyOf(allNodes);
}
 

private void checkLinks(BoundedLocalCache<K, V> cache,
    ImmutableList<LinkedDeque<Node<K, V>>> deques, DescriptionBuilder desc) {
  int size = 0;
  long weightedSize = 0;
  Set<Node<K, V>> seen = Sets.newIdentityHashSet();
  for (LinkedDeque<Node<K, V>> deque : deques) {
    size += deque.size();
    weightedSize += scanLinks(cache, seen, deque, desc);
  }
  if (cache.size() != size) {
    desc.expectThat(() -> "deque size " + deques, size, is(cache.size()));
  }

  Supplier<String> errorMsg = () -> String.format(
      "Size != list length; pending=%s, additional: %s", cache.writeBuffer().size(),
      Sets.difference(seen, ImmutableSet.copyOf(cache.data.values())));
  desc.expectThat(errorMsg, cache.size(), is(seen.size()));

  if (cache.evicts()) {
    long weighted = weightedSize;
    long expectedWeightedSize = Math.max(0, cache.weightedSize());
    Supplier<String> error = () -> String.format(
        "WeightedSize != link weights [%d vs %d] {%d vs %d}",
        expectedWeightedSize, weighted, seen.size(), cache.size());
    desc.expectThat("non-negative weight", weightedSize, is(greaterThanOrEqualTo(0L)));
    desc.expectThat(error, expectedWeightedSize, is(weightedSize));
  }
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final MethodBindings mb = new MethodBindings();
	node.accept(mb);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<String, ASTNode> entry : mb.methodNamePostions
			.entries()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.add(entry.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final VariableBindingFinder bindingFinder = new VariableBindingFinder();
	node.accept(bindingFinder);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<Integer, List<ASTNode>> variableBindings : bindingFinder.variableBinding
			.entrySet()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.addAll(variableBindings.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

private void checkTimerWheel(BoundedLocalCache<K, V> cache) {
  if (!cache.expiresVariable()) {
    return;
  }

  Set<Node<K, V>> seen = Sets.newIdentityHashSet();
  for (int i = 0; i < cache.timerWheel().wheel.length; i++) {
    for (int j = 0; j < cache.timerWheel().wheel[i].length; j++) {
      Node<K, V> sentinel = cache.timerWheel().wheel[i][j];
      desc.expectThat("Wrong sentinel prev",
          sentinel.getPreviousInVariableOrder().getNextInVariableOrder(), sameInstance(sentinel));
      desc.expectThat("Wrong sentinel next",
          sentinel.getNextInVariableOrder().getPreviousInVariableOrder(), sameInstance(sentinel));
      desc.expectThat("Sentinel must be first element", sentinel, instanceOf(Sentinel.class));

      for (Node<K, V> node = sentinel.getNextInVariableOrder();
          node != sentinel; node = node.getNextInVariableOrder()) {
        Node<K, V> next = node.getNextInVariableOrder();
        Node<K, V> prev = node.getPreviousInVariableOrder();
        long duration = node.getVariableTime() - cache.timerWheel().nanos;
        desc.expectThat("Expired", duration, greaterThan(0L));
        desc.expectThat("Loop detected", seen.add(node), is(true));
        desc.expectThat("Wrong prev", prev.getNextInVariableOrder(), is(sameInstance(node)));
        desc.expectThat("Wrong next", next.getPreviousInVariableOrder(), is(sameInstance(node)));
      }
    }
  }
  desc.expectThat("Timers != Entries", seen, hasSize(cache.size()));
}
 

@SuppressWarnings("unchecked")
@Override
public <T extends Entity> T merge(T entity) {
    checkNotNullArgument(entity, "entity is null");

    disableListeners = true;
    T result;
    try {
        Set<Entity> merged = Sets.newIdentityHashSet();
        result = (T) internalMerge(entity, merged, true);
    } finally {
        disableListeners = false;
    }
    return result;
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final VariableBindingFinder bindingFinder = new VariableBindingFinder();
	node.accept(bindingFinder);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<IVariableBinding, List<ASTNode>> variableBindings : bindingFinder.variableScope
			.entrySet()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.addAll(variableBindings.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

@Override
public void destroyPipeline() {
  servletPipeline.destroy();

  Set<Filter> destroyedSoFar = Sets.newIdentityHashSet();
  for (FilterDefinition filterDefinition : filterDefinitions()) {
    filterDefinition.destroy(destroyedSoFar);
  }
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final MethodBindings mb = new MethodBindings();
	node.accept(mb);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<String, ASTNode> entry : mb.methodNamePostions
			.entries()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.add(entry.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final VariableBindingFinder bindingFinder = new VariableBindingFinder();
	node.accept(bindingFinder);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<Integer, List<ASTNode>> variableBindings : bindingFinder.variableBinding
			.entrySet()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.addAll(variableBindings.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

private static EnumSet<Octant> select(EnumFacing dir) {
	Set<Octant> result = Sets.newIdentityHashSet();
	for (Octant o : values())
		if (o.dirs.contains(dir))
			result.add(o);

	return EnumSet.copyOf(result);
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final VariableBindingFinder bindingFinder = new VariableBindingFinder();
	node.accept(bindingFinder);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<Integer, List<ASTNode>> variableBindings : bindingFinder.variableBinding
			.entrySet()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.addAll(variableBindings.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

/**
 * Returns the first throwable of the given {@code wantedThrowableType} by visiting the provided
 * throwable and its causes recursively.
 *
 * @param wantedThrowableType the throwable type to find
 * @param throwable the throwable to start with
 * @param <T> the desired throwable subtype
 * @return the first throwable found of the given type, or null if none found
 */
public static <T extends Throwable> T findThrowableInCause(Class<T> wantedThrowableType, Throwable throwable) {
    Set<Throwable> visitedObjects = Sets.newIdentityHashSet();
    Throwable currentThrowable = throwable;
    while (currentThrowable != null && !visitedObjects.contains(currentThrowable)) {
        if (wantedThrowableType.isInstance(currentThrowable)) {
            return wantedThrowableType.cast(currentThrowable);
        }
        visitedObjects.add(currentThrowable);
        currentThrowable = currentThrowable.getCause();
    }
    return null;
}
 

@Override
public Set<Set<ASTNode>> getNameBindings(final ASTNode node) {
	final MethodBindings mb = new MethodBindings();
	node.accept(mb);

	final Set<Set<ASTNode>> nameBindings = Sets.newHashSet();
	for (final Entry<String, ASTNode> entry : mb.methodNamePostions
			.entries()) {
		final Set<ASTNode> boundNodes = Sets.newIdentityHashSet();
		boundNodes.add(entry.getValue());
		nameBindings.add(boundNodes);
	}
	return nameBindings;
}
 

public static Prel uniqifyGraph(Prel p) {
  Set<Prel> data = Sets.newIdentityHashSet();
  return p.accept(INSTANCE, data);
}
 

@Override
public void visitDiffEntry(final DiffEntry entry, final EditList editList,
		final RevCommit commit) throws IOException {
	final String sha = commit.name();
	if (entry.getNewPath().equals("/dev/null")) {
		currentStateOfIdentifiers.removeAll(entry.getOldPath()).forEach(
				i -> {
					if (!i.isDeleted()) {
						i.setIdentifierDeleted();
					}
				});
		return;
	}
	final String repositoryFolder = repository.getRepository()
			.getWorkTree() + "/";

	final File targetFile = new File(repositoryFolder + entry.getNewPath());
	final Set<IdentifierInformation> newIdentifierInfo = infoScanner
			.scanFile(targetFile, commit.name());
	if (currentStateOfIdentifiers.containsKey(entry.getOldPath())) {
		final Collection<IdentifierInformationThroughTime> state = currentStateOfIdentifiers
				.get(entry.getOldPath());
		final List<IdentifierInformationThroughTime> allIitts = Lists
				.newArrayList(state);
		final Set<IdentifierInformationThroughTime> setIitts = Sets
				.newIdentityHashSet();
		setIitts.addAll(state);
		checkArgument(setIitts.size() == allIitts.size(),
				"Before adding, state was inconsistent for ", targetFile);
		updateIdentifierInfoState(state, newIdentifierInfo, editList,
				entry.getNewPath());

		if (!entry.getOldPath().equals(entry.getNewPath())) {
			currentStateOfIdentifiers.putAll(entry.getNewPath(), state);
			currentStateOfIdentifiers.removeAll(entry.getOldPath());
		}
	} else {
		// This is a new file or a file we failed to index before, add
		// happily...
		// checkArgument(entry.getOldPath().equals("/dev/null"));
		final List<IdentifierInformationThroughTime> infosThroughTime = Lists
				.newArrayList();
		newIdentifierInfo
				.forEach(info -> {
					final IdentifierInformationThroughTime inf = new IdentifierInformationThroughTime();
					inf.addInformation(info);
					infosThroughTime.add(inf);
				});
		currentStateOfIdentifiers.putAll(entry.getNewPath(),
				infosThroughTime);
	}

}
 

private Set<TypeParam> process(final Type type)
{
    params = Sets.newIdentityHashSet();
    visitType(type);
    return params;
}
 

@Override
public void readIntializationData(PacketBuffer dis) throws IOException {
	final int count = dis.readVarInt();

	final ImmutableList.Builder<ISyncableObject> idToObject = ImmutableList.builder();

	final ImmutableMap.Builder<ISyncableObject, Integer> objectToId = ImmutableMap.builder();

	final Set<ISyncableObject> changedObjects = Sets.newIdentityHashSet();

	for (int i = 0; i < count; i++) {
		final String id = dis.readString(Short.MAX_VALUE);
		final int typeId = dis.readVarInt();

		final SyncableObjectType type = SyncableObjectTypeRegistry.getType(typeId);

		ISyncableObject object = availableObjects.get(id);
		if (object == null || !type.isValidType(object))
			object = type.createDummyObject();

		object.readFromStream(dis);

		idToObject.add(object);
		objectToId.put(object, i);

		changedObjects.add(object);
	}

	this.idToObject = idToObject.build();
	this.objectToId = objectToId.build();
	this.bitmapLength = (count + 7) / 8;

	notifySyncListeners(updateListeners, Collections.unmodifiableSet(changedObjects));
}