Java SetView类代码示例

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private static Map<String, Set<String>> diffMap(Map<String, Byte[]> oldNodeData,
		Map<String, Byte[]> nodeWithData) {
	Set<String> oldChildNode = oldNodeData.keySet();
	Set<String> newChildNode = nodeWithData.keySet();
	SetView<String> view1 = Sets.difference(oldChildNode, newChildNode);// 下线的
	SetView<String> view2 = Sets.difference(newChildNode, oldChildNode);// 上线的
	Map<String, Set<String>> resultMap = new ConcurrentHashMap<String, Set<String>>();
	Set<String> offlineSet = new HashSet<String>();
	Set<String> onlineSet = new HashSet<String>();
	long before = System.currentTimeMillis();
	offlineSet = view1.copyInto(offlineSet);
	onlineSet = view2.copyInto(onlineSet);
	long after = System.currentTimeMillis();
	
	//Long[] longList = new Long[]{after-before,new Long(onlineSet.size()),new Long(offlineSet.size())};
	//logger.debug("SAF diff set spend time:{},online node MAP size:{} offlien node MAP size:{}",longList);
	resultMap.put(PathCache.OFFLINESET, offlineSet);
	resultMap.put(PathCache.ONLINESET, onlineSet);
	return resultMap;

}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private <T extends IForgeRegistryEntry<T>> FMLControlledNamespacedRegistry<T> createRegistry(ResourceLocation registryName, Class<T> type, ResourceLocation defaultObjectKey, int minId, int maxId, IForgeRegistry.AddCallback<T> addCallback, IForgeRegistry.ClearCallback<T> clearCallback, IForgeRegistry.CreateCallback<T> createCallback, IForgeRegistry.SubstitutionCallback<T> substitutionCallback)
{
    Set<Class<?>> parents = Sets.newHashSet();
    findSuperTypes(type, parents);
    SetView<Class<?>> overlappedTypes = Sets.intersection(parents, registrySuperTypes.keySet());
    if (!overlappedTypes.isEmpty())
    {
        Class<?> foundType = overlappedTypes.iterator().next();
        FMLLog.severe("Found existing registry of type %1s named %2s, you cannot create a new registry (%3s) with type %4s, as %4s has a parent of that type", foundType, registrySuperTypes.get(foundType), registryName, type);
        throw new IllegalArgumentException("Duplicate registry parent type found - you can only have one registry for a particular super type");
    }
    FMLControlledNamespacedRegistry<T> fmlControlledNamespacedRegistry = new FMLControlledNamespacedRegistry<T>(defaultObjectKey, minId, maxId, type, registries, addCallback, clearCallback, createCallback, substitutionCallback);
    registries.put(registryName, fmlControlledNamespacedRegistry);
    registrySuperTypes.put(type, registryName);
    return getRegistry(registryName, type);
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private synchronized void notifyGroupChange(Iterable<String> memberIds) {
  ImmutableSet<String> newMemberIds = ImmutableSortedSet.copyOf(memberIds);
  Set<String> existingMemberIds = servicesByMemberId.asMap().keySet();

  // Ignore no-op state changes except for the 1st when we've seen no group yet.
  if ((serverSet == null) || !newMemberIds.equals(existingMemberIds)) {
    SetView<String> deletedMemberIds = Sets.difference(existingMemberIds, newMemberIds);
    // Implicit removal from servicesByMemberId.
    existingMemberIds.removeAll(ImmutableSet.copyOf(deletedMemberIds));

    Iterable<ServiceInstance> serviceInstances = Iterables.filter(
        Iterables.transform(newMemberIds, MAYBE_FETCH_NODE), Predicates.notNull());

    notifyServerSetChange(ImmutableSet.copyOf(serviceInstances));
  }
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private void logChange(ImmutableSet<ServiceInstance> newServerSet) {
  StringBuilder message = new StringBuilder("server set " + group.getPath() + " change: ");
  if (serverSet.size() != newServerSet.size()) {
    message.append("from ").append(serverSet.size())
        .append(" members to ").append(newServerSet.size());
  }

  Joiner joiner = Joiner.on("\n\t\t");

  SetView<ServiceInstance> left = Sets.difference(serverSet, newServerSet);
  if (!left.isEmpty()) {
    message.append("\n\tleft:\n\t\t").append(joiner.join(left));
  }

  SetView<ServiceInstance> joined = Sets.difference(newServerSet, serverSet);
  if (!joined.isEmpty()) {
    message.append("\n\tjoined:\n\t\t").append(joiner.join(joined));
  }

  LOG.info(message.toString());
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private SqlCompleter createSqlCompleter(Connection jdbcConnection) {

        SqlCompleter completer = null;
        try {
            Set<String> keywordsCompletions = SqlCompleter.getSqlKeywordsCompletions(jdbcConnection);
            Set<String> dataModelCompletions =
                    SqlCompleter.getDataModelMetadataCompletions(jdbcConnection);
            SetView<String> allCompletions = Sets.union(keywordsCompletions, dataModelCompletions);
            completer = new SqlCompleter(allCompletions, dataModelCompletions);

        } catch (IOException | SQLException e) {
            logger.error("Cannot create SQL completer", e);
        }

        return completer;
    }
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
public void updateDataModelMetaData(Connection connection) {

    try {
      Set<String> newModelCompletions = getDataModelMetadataCompletions(connection);
      logger.debug("New model metadata is:" + Joiner.on(',').join(newModelCompletions));

      // Sets.difference(set1, set2) - returned set contains all elements that are contained by set1
      // and not contained by set2. set2 may also contain elements not present in set1; these are
      // simply ignored.
      SetView<String> removedCompletions = Sets.difference(modelCompletions, newModelCompletions);
      logger.debug("Removed Model Completions: " + Joiner.on(',').join(removedCompletions));
      this.getStrings().removeAll(removedCompletions);

      SetView<String> newCompletions = Sets.difference(newModelCompletions, modelCompletions);
      logger.debug("New Completions: " + Joiner.on(',').join(newCompletions));
      this.getStrings().addAll(newCompletions);

      modelCompletions = newModelCompletions;

    } catch (SQLException e) {
      logger.error("Failed to update the metadata conmpletions", e);
    }
  }
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
/**
 * It validates that peer-clusters can't coexist in replication-clusters
 * 
 * @param clusterName:
 *            given cluster whose peer-clusters can't be present into replication-cluster list
 * @param clusters:
 *            replication-cluster list
 */
private void validatePeerClusterConflict(String clusterName, Set<String> replicationClusters) {
    try {
        ClusterData clusterData = clustersCache().get(path("clusters", clusterName)).orElseThrow(
                () -> new RestException(Status.PRECONDITION_FAILED, "Invalid replication cluster " + clusterName));
        Set<String> peerClusters = clusterData.getPeerClusterNames();
        if (peerClusters != null && !peerClusters.isEmpty()) {
            SetView<String> conflictPeerClusters = Sets.intersection(peerClusters, replicationClusters);
            if (!conflictPeerClusters.isEmpty()) {
                log.warn("[{}] {}'s peer cluster can't be part of replication clusters {}", clientAppId(),
                        clusterName, conflictPeerClusters);
                throw new RestException(Status.CONFLICT,
                        String.format("%s's peer-clusters %s can't be part of replication-clusters %s", clusterName,
                                conflictPeerClusters, replicationClusters));
            }
        }
    } catch (RestException re) {
        throw re;
    } catch (Exception e) {
        log.warn("[{}] Failed to get cluster-data for {}", clientAppId(), clusterName, e);
    }
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private SqlCompleter createSqlCompleter(Connection jdbcConnection) {

    SqlCompleter completer = null;
    try {
      Set<String> keywordsCompletions = SqlCompleter.getSqlKeywordsCompletions(jdbcConnection);
      Set<String> dataModelCompletions =
          SqlCompleter.getDataModelMetadataCompletions(jdbcConnection);
      SetView<String> allCompletions = Sets.union(keywordsCompletions, dataModelCompletions);
      completer = new SqlCompleter(allCompletions, dataModelCompletions);

    } catch (IOException | SQLException e) {
      logger.error("Cannot create SQL completer", e);
    }

    return completer;
  }
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
@Override
protected void doRun(boolean write, File outputFile) throws Exception {
  boolean dropExisting = getCommandLine().hasOption(DROP_EXISTING_OPTION);
  if (getCommandLine().hasOption(SCHEMA_NAME_FILTER)) {
    String[] nameArgs = getCommandLine().getOptionValues(SCHEMA_NAME_FILTER);
    Set<String> includeNames = ImmutableSet.copyOf(nameArgs);
    Set<String> allNames = getDbToolContext().getSchemaNames();
    SetView<String> filteredNames = Sets.intersection(allNames, includeNames);
    if (write) {
      System.out.println("Filtered " + allNames + " to " + filteredNames);
    }
    getDbToolContext().setSchemaNames(filteredNames);
  }
  if (getDbToolContext().getSchemaNames().isEmpty()) {
    System.out.println("No schemas specified, or all filtered out");
  } else {
    new DbCreateOperation(getDbToolContext(), write, outputFile, dropExisting).execute();
    if (write) {
      System.out.println("Database objects created successfully");
    }
  }
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
public void analyze() {
	log.info("Starting analyzing for user: " + twitterUser);
	
	//Create the CSVFormat object
	createFileIfNotExisting(filenameFollowerIDsDelta());
	createFileIfNotExisting(filenameFollowerIDsCurrent());
	
	Set<String> currentIDsFromFile = readAllIDsFromCurrentFile(); 
	currentIDsFromTwitter = getAllFollwerIDsFromTwitter();
	
	SetView<String> symmetricDifference = Sets.symmetricDifference(currentIDsFromFile, currentIDsFromTwitter);
	
	if (symmetricDifference.size() == 0) {
		log.info("No new followers were found.");
	} else {
		processSyncDifferences(currentIDsFromFile, symmetricDifference);

		deleteAndRecreateFile(filenameFollowerIDsCurrent());
		writeCurrentFollowerIDFile(currentIDsFromTwitter);
	}
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
private void syncListenedChannels() {
  if (m_channels.equals(m_currentListenedChannels)) {
    return;
  }

  final Set<NotificationChannel> channels = Sets.newHashSet(m_channels);
  final SetView<NotificationChannel> toUnlisten =
      Sets.difference(m_currentListenedChannels, channels);
  final SetView<NotificationChannel> toListen =
      Sets.difference(channels, m_currentListenedChannels);

  if (!toUnlisten.isEmpty()) {
    sendUnlistens(toUnlisten);
  }
  if (!toListen.isEmpty()) {
    sendListens(toListen);
  }
  if (!toUnlisten.isEmpty() || !toListen.isEmpty()) {
    m_currentListenedChannels.clear();
    m_currentListenedChannels.addAll(channels);
  }
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
public Map<String, Class<?>> defineClasses(Map<String, byte[]> newClasses)
{
    SetView<String> conflicts = Sets.intersection(pendingClasses.keySet(), newClasses.keySet());
    Preconditions.checkArgument(conflicts.isEmpty(), "The classes %s have already been defined", conflicts);

    pendingClasses.putAll(newClasses);
    try {
        Map<String, Class<?>> classes = new HashMap<>();
        for (String className : newClasses.keySet()) {
            try {
                Class<?> clazz = loadClass(className);
                classes.put(className, clazz);
            }
            catch (ClassNotFoundException e) {
                // this should never happen
                throw Throwables.propagate(e);
            }
        }
        return classes;
    }
    finally {
        pendingClasses.keySet().removeAll(newClasses.keySet());
    }
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
/**
 * @author 胡天翔
 */
@Test
public void testFilterProjectMembers() {
    List<User> list1 = new ArrayList<User>(), list2 = new ArrayList<User>();
    list1.add(getASampleUser(0));
    list1.add(getASampleUser(1));
    list1.add(getASampleUser(2));
    list2.add(getASampleUser(1));
    list2.add(getASampleUser(2));
    list2.add(getASampleUser(3));
    SetView<User> intersection = Sets.intersection(new HashSet<User>(list1), new HashSet<User>(list2));
    
    UserServiceImpl spyUserServiceImpl = Mockito.spy(testedUserServiceImpl);
    Mockito.doReturn(list2).when(spyUserServiceImpl).getUserByProjectId(ModuleHelper.projectId);
    
    List<User> user = spyUserServiceImpl.filterProjectMembers(list1, ModuleHelper.projectId);
    
    Mockito.verify(spyUserServiceImpl).filterProjectMembers(list1, ModuleHelper.projectId);
    Mockito.verify(spyUserServiceImpl).getUserByProjectId(ModuleHelper.projectId);
    Mockito.verifyNoMoreInteractions(spyUserServiceImpl);
    
    assertEquals(intersection.size(), Sets.intersection(intersection, new HashSet<User>(user)).size());
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
/** Returns an error message if request is not valid. Checks basic request formatting. */
static String validateRequest(RPC.CreateOrganizationRequest request) {
  if (Strings.isNullOrEmpty(request.name)) {
    return "name cannot be empty";
  }
  if (Strings.isNullOrEmpty(request.publicKey)) {
    return "publicKey cannot be empty";
  }
  if (request.adminEncryptedKeys == null || request.adminEncryptedKeys.isEmpty()) {
    return "adminEncryptedKeys cannot be empty";
  }
  if (request.memberGroupKeys == null || request.memberGroupKeys.isEmpty()) {
    return "memberGroupKeys cannot be empty";
  }

  // ensure that every admin is also a member
  SetView<String> adminsNotInMembers = Sets.difference(
      request.adminEncryptedKeys.keySet(), request.memberGroupKeys.keySet());
  if (!adminsNotInMembers.isEmpty()) {
    return "each admin must be a member";
  }
  return null;
}
 

import com.google.common.collect.Sets.SetView; //导入依赖的package包/类
/**
 * Two instances of {@link PackageInventory} are identical if they
 * contain the same set packages.
 */
@Override
public boolean equals(Object obj) {
	if (!(obj instanceof PackageInventory)){
		return false;
	}
	PackageInventory ref = (PackageInventory) obj;
	// comparison of the PIDs is sufficient
	SetView<PID> symmDiff;
	// synchronized access to the underlying maps
	synchronized (packagesByIdMap){
		synchronized (ref.packagesByIdMap) {
			symmDiff = Sets.symmetricDifference(ref.packagesByIdMap.keySet(), this.packagesByIdMap.keySet());
		}
	}
	return symmDiff.isEmpty();
}