Java LinkedHashSet.isEmpty方法代码示例

import java.util.LinkedHashSet; //导入方法依赖的package包/类
public void unregisterThrower(Class<?> interfaceClass, IEventThrower<?> thrower, boolean keepSubscribers){
	synchronized (EVENT_THROWERS) {
		if(EVENT_THROWERS.containsKey(interfaceClass)){
			LinkedHashSet<IEventThrower<?>> list = EVENT_THROWERS.get(interfaceClass);
			if(keepSubscribers){
				Queue<Object> toKeep = new ArrayDeque<>();
				Iterator<?> subscribers = thrower.getSubscribers();
				while(subscribers.hasNext()){
					Object listener = subscribers.next();
					toKeep.add(listener);
				}
				if(!QUEUED_LISTENERS.containsKey(interfaceClass)){
					QUEUED_LISTENERS.put(interfaceClass, toKeep);
				}
			}else{
				thrower.clearSubscribers();
			}
			list.remove(thrower);
			if(list.isEmpty()){
				EVENT_THROWERS.remove(interfaceClass);	
			}
		}
	}
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * Computes more critical pairs for this set
 * @return a nonempty set of Critical pairs if there were more critical pairs.
 * Otherwise an empty set (this means that this.ruleTuples.isEmpty after this call)
 */
private Set<CriticalPair> computeMorePairs() {
    LinkedHashSet<CriticalPair> result = new LinkedHashSet<>(0);
    if (!this.ruleTuplesToProcess.isEmpty()) {
        Iterator<RuleTuple> it = this.ruleTuplesToProcess.iterator();
        while (result.isEmpty() && it.hasNext()) {
            RuleTuple nextTuple = it.next();
            result = CriticalPair.computeCriticalPairs(nextTuple.rule1, nextTuple.rule2);
            //Add the new pairs to the internal set
            this.pairMap.put(nextTuple, result);
            //remove the tuple
            it.remove();
        }
    }
    //return the new pairs
    return result;
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
public static PacketInfo getEarliest(LinkedHashSet<PacketInfo> packetInfos) {
    if ((packetInfos == null) || (packetInfos.isEmpty())) {
        throw new IllegalArgumentException("Cannot get earliest of null or empty PacketInfo set!");
    }
    PacketInfo earliest = null;
    Timestamp earliestTimestamp = null;
    for (PacketInfo current : packetInfos) {
        if (earliest == null) {
            earliest = current;
            earliestTimestamp = Timestamp.valueOf(current.get(PacketInfo.TIMESTAMP));
        } else {
            Timestamp currentTimestamp = Timestamp.valueOf(current.get(PacketInfo.TIMESTAMP));
            if (currentTimestamp.before(earliestTimestamp)) {
                earliest = current;
                earliestTimestamp = currentTimestamp;
            }
        }
    }
    return earliest;
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
public static PacketInfo getLatest(LinkedHashSet<PacketInfo> packetInfos) {
    if ((packetInfos == null) || (packetInfos.isEmpty())) {
        throw new IllegalArgumentException("Cannot get latest of null or empty PacketInfo set!");
    }
    PacketInfo latest = null;
    Timestamp latestTimestamp = null;
    for (PacketInfo current : packetInfos) {
        if (latest == null) {
            latest = current;
            latestTimestamp = Timestamp.valueOf(current.get(PacketInfo.TIMESTAMP));
        } else {
            Timestamp currentTimestamp = Timestamp.valueOf(current.get(PacketInfo.TIMESTAMP));
            if (currentTimestamp.after(latestTimestamp)) {
                latest = current;
                latestTimestamp = currentTimestamp;
            }
        }
    }
    return latest;
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
@Override
public synchronized void removeTransformer(Bundle pBundle, ClassTransformer transformer) {
    LinkedHashSet<ClassTransformer> set = registeredTransformers.get(pBundle);
    if (set == null || !set.remove(transformer)) {
        throw new IllegalStateException("Transformer " + transformer + " not registered");
    }
    if (set.isEmpty()) {
        registeredTransformers.remove(pBundle);
    }
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
LinkedHashSet<PolicySet> filterPolicySetsByPriority(final String subjectIdentifier, final String uri,
        final List<PolicySet> allPolicySets, final LinkedHashSet<String> policySetsEvaluationOrder)
        throws IllegalArgumentException {

    if (policySetsEvaluationOrder.isEmpty()) {
        if (allPolicySets.size() > 1) {
            LOGGER.error(
                    "Found more than one policy set during policy evaluation and "
                            + "no evaluation order is provided. subjectIdentifier='{}', resourceURI='{}'",
                    subjectIdentifier, uri);
            throw new IllegalArgumentException("More than one policy set exists for this zone. "
                    + "Please provide an ordered list of policy set names to consider for this evaluation and "
                    + "resubmit the request.");
        } else {
            return new LinkedHashSet<>(allPolicySets);
        }
    }

    Map<String, PolicySet> allPolicySetsMap = allPolicySets.stream()
            .collect(Collectors.toMap(PolicySet::getName, Function.identity()));
    LinkedHashSet<PolicySet> filteredPolicySets = new LinkedHashSet<>();
    for (String policySetId : policySetsEvaluationOrder) {
        PolicySet policySet = allPolicySetsMap.get(policySetId);
        if (policySet == null) {
            LOGGER.error("No existing policy set matches policy set in the evaluation order of the request. "
                    + "Subject: {}, Resource: {}", subjectIdentifier, uri);
            throw new IllegalArgumentException(
                    "No existing policy set matches policy set in the evaluaion order of the request. "
                            + "Please review the policy evauation order and resubmit the request.");
        } else {
            filteredPolicySets.add(policySet);
        }
    }
    return filteredPolicySets;
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * 
 */
private String[] createDocComment(boolean hasReturnType,
        LinkedHashSet<TypeDescriptor> throwsTypes,
        String[] methodDescription, String returnTypeDescription) {
    
    ArrayList<String> lines = new ArrayList<>();
    
    if (methodDescription != null) {
        for (int i=0;i<methodDescription.length;i++) {
            lines.add(methodDescription[i]);
        }
    }
    
    boolean hasThrowTypes = !throwsTypes.isEmpty();
    
    if ((methodDescription != null) && (methodDescription.length > 0) &&
        (hasReturnType || hasThrowTypes)) {
        
        lines.add("");
    }
    
    if (hasReturnType) {
        lines.add("@return "+returnTypeDescription);
    }
    
    if (hasThrowTypes) {
        Iterator<TypeDescriptor> iterator = throwsTypes.iterator();
        
        while (iterator.hasNext()) {
            TypeDescriptor curType = iterator.next();
            String typeName = curType.getSimpleName();
            String typeDescription = getThrowableDescription(curType);
            
            lines.add("@throws "+typeName+" "+typeDescription);
        }
    }
    
    return lines.toArray(SystemToolkit.EMPTY_STRING_ARRAY);
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * This methods takes an API-Element and pulls the projectComparisons along the suptertype chain.
 *
 * Does nothing if apiElement is null.
 *
 * @param filter
 *            applied to each encountered projectComparison
 * @param actionProvider
 *            function to apply on filtered ProjectComparinsonEntries.
 * @param apiElement
 *            concrete API element to start from.
 */
public <T extends TClassifier> void interfaceApiSupertypeWalker(Predicate<? super ProjectComparisonEntry> filter,
		Function<T, Consumer<? super ProjectComparisonEntry>> actionProvider,
		ProjectComparisonAdapter projectComparisonAdapter, /* ProjectComparisonEntry compareEntry, */
		T apiElement, Class<T> castGuard) {
	if (apiElement == null) {
		// no apiElemnt means no one can directly call the concrete implementation
		// from projects
		return;
	}

	LinkedHashSet<T> toBeProcessedSuperInterfaces = new LinkedHashSet<>();
	LinkedHashSet<T> processedSuperInterfaces = new LinkedHashSet<>();
	// Yes it is correct ~Not correct~, since we need VirtualMethods for the direct missing parts:: //
	toBeProcessedSuperInterfaces.add(apiElement);
	// includeAdditionsSuperInterfaces(toBeProcessedSuperInterfaces, processedSuperInterfaces, apiInterface);

	while (!toBeProcessedSuperInterfaces.isEmpty()) {

		Iterator<T> iter = toBeProcessedSuperInterfaces.iterator();
		T pivot = iter.next();
		iter.remove();
		// do not process built-in types
		if (TypeUtils.isBuiltIn(pivot)) {
			continue;
		}
		// collect to be processed:
		includeAdditionsSuperInterfaces2(toBeProcessedSuperInterfaces, processedSuperInterfaces, pivot, castGuard);
		// go over methods.
		// Is the superInterface from the same Project ? If not it cannot be an API problem of this
		// implementation.
		TModule superModule = pivot.getContainingModule();

		if (superModule != null) {
			ProjectComparisonEntry useCompareEntry = projectComparisonAdapter.getEntryFor(superModule);
			if (useCompareEntry == null) {
				if (logger.isDebugEnabled()) {
					logger.debug("No comparison found for pivot = " + pivot.getName());
				}
			} else {
				// Is there an API entry at all ? --> If not it was just a normal implementation of some library ?
				ProjectComparisonEntry superInterfaceCompareEntry = useCompareEntry.getChildForElementAPI(pivot);
				if (superInterfaceCompareEntry != null) {
					// Is there a difference between this API and the implementations ?
					if (superInterfaceCompareEntry.hasChildren()) {
						// get the ones which are missing implementations; others are real errors and will not be
						// touched!
						superInterfaceCompareEntry.allChildren()
								.filter(filter)
								.forEach(actionProvider.apply(pivot));
					}
				} // end if superInterfaceCompareEntry != null
			}
		} // end if null-check for module...
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("-#- could not get module for super-classifier: " + pivot.getName() + " of type "
						+ pivot.getTypeAsString() + " providedByRuntime=" + pivot.isProvidedByRuntime());
			}
		}
	}

}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * Semantically equivalent to 'nativeToFlavor.get(nat)'. This method
 * handles the case where 'nat' is not found in 'nativeToFlavor'. In that
 * case, a new DataFlavor is synthesized, stored, and returned, if and
 * only if the specified native is encoded as a Java MIME type.
 */
private LinkedHashSet<DataFlavor> nativeToFlavorLookup(String nat) {
    LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat);


    if (nat != null && !disabledMappingGenerationKeys.contains(nat)) {
        DataTransferer transferer = DataTransferer.getInstance();
        if (transferer != null) {
            LinkedHashSet<DataFlavor> platformFlavors =
                transferer.getPlatformMappingsForNative(nat);
            if (!platformFlavors.isEmpty()) {
                if (flavors != null) {
                    // Prepending the platform-specific mappings ensures
                    // that the flavors added with
                    // addFlavorForUnencodedNative() are at the end of
                    // list.
                    platformFlavors.addAll(flavors);
                }
                flavors = platformFlavors;
            }
        }
    }

    if (flavors == null && isJavaMIMEType(nat)) {
        String decoded = decodeJavaMIMEType(nat);
        DataFlavor flavor = null;

        try {
            flavor = new DataFlavor(decoded);
        } catch (Exception e) {
            System.err.println("Exception \"" + e.getClass().getName() +
                               ": " + e.getMessage()  +
                               "\"while constructing DataFlavor for: " +
                               decoded);
        }

        if (flavor != null) {
            flavors = new LinkedHashSet<>(1);
            getNativeToFlavor().put(nat, flavors);
            flavors.add(flavor);
            flavorsForNativeCache.remove(nat);

            LinkedHashSet<String> natives = getFlavorToNative().get(flavor);
            if (natives == null) {
                natives = new LinkedHashSet<>(1);
                getFlavorToNative().put(flavor, natives);
            }
            natives.add(nat);
            nativesForFlavorCache.remove(flavor);
        }
    }

    return (flavors != null) ? flavors : new LinkedHashSet<>(0);
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * Semantically equivalent to 'flavorToNative.get(flav)'. This method
 * handles the case where 'flav' is not found in 'flavorToNative' depending
 * on the value of passes 'synthesize' parameter. If 'synthesize' is
 * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by
 * encoding the DataFlavor's MIME type. Otherwise an empty List is returned
 * and 'flavorToNative' remains unaffected.
 */
private LinkedHashSet<String> flavorToNativeLookup(final DataFlavor flav,
                                                   final boolean synthesize) {

    LinkedHashSet<String> natives = getFlavorToNative().get(flav);

    if (flav != null && !disabledMappingGenerationKeys.contains(flav)) {
        DataTransferer transferer = DataTransferer.getInstance();
        if (transferer != null) {
            LinkedHashSet<String> platformNatives =
                transferer.getPlatformMappingsForFlavor(flav);
            if (!platformNatives.isEmpty()) {
                if (natives != null) {
                    // Prepend the platform-specific mappings to ensure
                    // that the natives added with
                    // addUnencodedNativeForFlavor() are at the end of
                    // list.
                    platformNatives.addAll(natives);
                }
                natives = platformNatives;
            }
        }
    }

    if (natives == null) {
        if (synthesize) {
            String encoded = encodeDataFlavor(flav);
            natives = new LinkedHashSet<>(1);
            getFlavorToNative().put(flav, natives);
            natives.add(encoded);

            LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(encoded);
            if (flavors == null) {
                flavors = new LinkedHashSet<>(1);
                getNativeToFlavor().put(encoded, flavors);
            }
            flavors.add(flav);

            nativesForFlavorCache.remove(flav);
            flavorsForNativeCache.remove(encoded);
        } else {
            natives = new LinkedHashSet<>(0);
        }
    }

    return new LinkedHashSet<>(natives);
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * Semantically equivalent to 'nativeToFlavor.get(nat)'. This method handles
 * the case where 'nat' is not found in 'nativeToFlavor'. In that case, a
 * new DataFlavor is synthesized, stored, and returned, if and only if the
 * specified native is encoded as a Java MIME type.
 */
private LinkedHashSet<DataFlavor> nativeToFlavorLookup(String nat) {
    LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(nat);

    if (nat != null && !disabledMappingGenerationKeys.contains(nat)) {
        DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService();
        if (desktopService.isDesktopPresent()) {
            LinkedHashSet<DataFlavor> platformFlavors =
                    desktopService.getPlatformMappingsForNative(nat);
            if (!platformFlavors.isEmpty()) {
                if (flavors != null) {
                    // Prepending the platform-specific mappings ensures
                    // that the flavors added with
                    // addFlavorForUnencodedNative() are at the end of
                    // list.
                    platformFlavors.addAll(flavors);
                }
                flavors = platformFlavors;
            }
        }
    }

    if (flavors == null && isJavaMIMEType(nat)) {
        String decoded = decodeJavaMIMEType(nat);
        DataFlavor flavor = null;

        try {
            flavor = new DataFlavor(decoded);
        } catch (Exception e) {
            System.err.println("Exception \"" + e.getClass().getName() +
                               ": " + e.getMessage()  +
                               "\"while constructing DataFlavor for: " +
                               decoded);
        }

        if (flavor != null) {
            flavors = new LinkedHashSet<>(1);
            getNativeToFlavor().put(nat, flavors);
            flavors.add(flavor);
            flavorsForNativeCache.remove(nat);

            LinkedHashSet<String> natives = getFlavorToNative().get(flavor);
            if (natives == null) {
                natives = new LinkedHashSet<>(1);
                getFlavorToNative().put(flavor, natives);
            }
            natives.add(nat);
            nativesForFlavorCache.remove(flavor);
        }
    }

    return (flavors != null) ? flavors : new LinkedHashSet<>(0);
}
 

import java.util.LinkedHashSet; //导入方法依赖的package包/类
/**
 * Semantically equivalent to 'flavorToNative.get(flav)'. This method
 * handles the case where 'flav' is not found in 'flavorToNative' depending
 * on the value of passes 'synthesize' parameter. If 'synthesize' is
 * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by
 * encoding the DataFlavor's MIME type. Otherwise an empty List is returned
 * and 'flavorToNative' remains unaffected.
 */
private LinkedHashSet<String> flavorToNativeLookup(final DataFlavor flav,
                                                   final boolean synthesize) {

    LinkedHashSet<String> natives = getFlavorToNative().get(flav);

    if (flav != null && !disabledMappingGenerationKeys.contains(flav)) {
        DesktopDatatransferService desktopService = DataFlavorUtil.getDesktopService();
        if (desktopService.isDesktopPresent()) {
            LinkedHashSet<String> platformNatives =
                    desktopService.getPlatformMappingsForFlavor(flav);
            if (!platformNatives.isEmpty()) {
                if (natives != null) {
                    // Prepend the platform-specific mappings to ensure
                    // that the natives added with
                    // addUnencodedNativeForFlavor() are at the end of
                    // list.
                    platformNatives.addAll(natives);
                }
                natives = platformNatives;
            }
        }
    }

    if (natives == null) {
        if (synthesize) {
            String encoded = encodeDataFlavor(flav);
            natives = new LinkedHashSet<>(1);
            getFlavorToNative().put(flav, natives);
            natives.add(encoded);

            LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(encoded);
            if (flavors == null) {
                flavors = new LinkedHashSet<>(1);
                getNativeToFlavor().put(encoded, flavors);
            }
            flavors.add(flav);

            nativesForFlavorCache.remove(flav);
            flavorsForNativeCache.remove(encoded);
        } else {
            natives = new LinkedHashSet<>(0);
        }
    }

    return new LinkedHashSet<>(natives);
}