Removes entries whose configurations are unreadable from the inventory.
@return the list of entries removed from the inventory
349952
List<File> removeUnreadable() {
		// List unreadable
		List<InventoryEntry> unreadable = configs.values()
				.stream()
				.filter(v->!v.getConfiguration().isPresent())
				.collect(Collectors.toList());
		// Remove from inventory
		unreadable.forEach(v->configs.remove(v.getIdentifier()));
		// Return the list of removed files
		return unreadable.stream()
				.map(v->v.getPath())
				.collect(Collectors.toList());
	}
286133
private void prune()
	{
		if (useSoftReferences)
		{
			Iterator<Map.Entry<String, Object>> it = cache.entrySet().iterator();

			while (it.hasNext())
			{
				final Map.Entry<String, Object> entry = it.next();

				if (dereference(entry.getValue()) == null)
					it.remove();
			}
		}
	}
68547
public List<SimpleOrderedMap<Object>> list() {
    List<SimpleOrderedMap<Object>> list = new ArrayList<>();
    for (Entry<String, String> entry : idToVersion.entrySet()) {
      SimpleOrderedMap<Object> item = new SimpleOrderedMap<>();
      item.add("id", entry.getKey());
      item.add("size", versionToItem.get(entry.getValue()).size);
      item.add("version", entry.getValue());
      item.add("expiration", expirationVersion.get(entry.getValue()));
      list.add(item);
    }
    return list;
  }
695947
public DrawerView clearItems() {
        for (DrawerItem item : mAdapter.getItems()) {
            item.detach();
        }
        mAdapter.clear();
        updateList();
        return this;
    }
181086
private List<AtlasEdge> removeUnusedEntries(AtlasVertex instanceVertex, String edgeLabel,
                                             Collection<AtlasEdge> currentEntries,
                                             Collection<AtlasEdge> newEntries,
                                             IDataType entryType, AttributeInfo attributeInfo) throws AtlasException {
        if (currentEntries != null && !currentEntries.isEmpty()) {
            LOG.debug("Removing unused entries from the old collection");
            if (entryType.getTypeCategory() == TypeCategory.STRUCT
                    || entryType.getTypeCategory() == TypeCategory.CLASS) {

                //Remove the edges for (current edges - new edges)
                List<AtlasEdge> cloneElements = new ArrayList<>(currentEntries);
                cloneElements.removeAll(newEntries);
                List<AtlasEdge> additionalElements = new ArrayList<>();

                if (LOG.isDebugEnabled()) {
                    LOG.debug("Removing unused entries from the old collection - {}", cloneElements);
                }

                if (!cloneElements.isEmpty()) {
                    for (AtlasEdge edge : cloneElements) {
                        boolean deleted = deleteHandler.deleteEdgeReference(edge, entryType.getTypeCategory(),
                                attributeInfo.isComposite, true);
                        if (!deleted) {
                            additionalElements.add(edge);
                        }
                    }
                }
                return additionalElements;
            }
        }
        return new ArrayList<>();
    }
1001288
public List<Object> removeAll(Object locator) {
		List<Object> components = new ArrayList<Object>();

		if (locator == null)
			return components;

		synchronized (_lock) {
			for (int index = _references.size() - 1; index >= 0; index--) {
				Reference reference = _references.get(index);
				if (reference.match(locator)) {
					_references.remove(index);
					components.add(reference.getComponent());
				}
			}
		}

		return components;
	}
143318
@Override
    public Map<K, V> clearAll() {
        Map<K, V> result = new LinkedHashMap<K, V>(map.size());

        for (Map.Entry<K, V> entry : map.entrySet()) {
            K key = entry.getKey();
            V value = entry.getValue();

            boolean removed = map.remove(key, value);

            if (removed) {
                result.put(key, value);
            }
        }

        return result;
    }
218442
public function purgeUnreachableWeakInstances() {
		foreach ($this->declaredInstances as $key=>$instance) {
			if (!isset($instance['weak']) || $instance['weak'] == false) {
				$this->walkForGarbageCollection($key);
			}
		}

		// At this point any instance with the "noGarbageCollect" attribute should be kept. Others should be eliminated.
		$keptInstances = array();
		foreach ($this->declaredInstances as $key=>$instance) {
			if (isset($instance['noGarbageCollect']) && $instance['noGarbageCollect'] == true) {
				// Let's clear the flag
				unset($this->declaredInstances[$key]['noGarbageCollect']);
			} else {
				// Let's delete the weak instance
				unset($this->declaredInstances[$key]);
			}
		}


	}
556359
@Override
	public Iterable<Map.Entry<K, V>> entries() {
		return Collections.unmodifiableSet(state.entrySet());
	}
97608
private void expungeExpiredEntries() {
        emptyQueue();
        if (lifetime == 0) {
            return;
        }
        int cnt = 0;
        long time = System.currentTimeMillis();
        for (Iterator<CacheEntry<K,V>> t = cacheMap.values().iterator();
                t.hasNext(); ) {
            CacheEntry<K,V> entry = t.next();
            if (entry.isValid(time) == false) {
                t.remove();
                cnt++;
            }
        }
        if (DEBUG) {
            if (cnt != 0) {
                System.out.println("Removed " + cnt
                        + " expired entries, remaining " + cacheMap.size());
            }
        }
    }
1333948
private List<PassFactory> getCodeRemovingPasses() {
    List<PassFactory> passes = new ArrayList<>();
    if (options.collapseObjectLiterals) {
      passes.add(collapseObjectLiterals);
    }

    if (options.inlineVariables || options.inlineLocalVariables) {
      passes.add(inlineVariables);
    } else if (options.inlineConstantVars) {
      passes.add(inlineConstants);
    }

    if (options.foldConstants) {
      passes.add(peepholeOptimizations);
    }

    if (options.removeDeadCode) {
      passes.add(removeUnreachableCode);
    }

    if (shouldRunRemoveUnusedCode()) {
      passes.add(removeUnusedCode);
    }

    assertAllLoopablePasses(passes);
    return passes;
  }
1213502
public java.util.List<UnsuccessfulItem> getUnsuccessful() {
        if (unsuccessful == null) {
            unsuccessful = new com.amazonaws.internal.SdkInternalList<UnsuccessfulItem>();
        }
        return unsuccessful;
    }
1286949
public Iterator<String> list() {
        try {
            final Enumeration<String> keys = pathRegistry.keys();
            return new Iterator<String>() {
                public boolean hasNext() { return keys.hasMoreElements(); }
                public String next() { return keys.nextElement(); }
                public void remove() { throw new UnsupportedOperationException(); }
            };
        } catch (LowlevelStorageException e) {
            throw new FaultException(e);
        }
    }
1097390
public Set<V> nonRemovedValues() {
        return map.values().stream().filter(entry -> !entry.removable).map(entry -> entry.val).collect(Collectors.toSet());
    }
869009
private void cleanupLists(PrefixKey key) {
    // Remove expired list entries. Keep track of the last list removed.
    NavigableMap<PrefixKey, CacheValue<Object>> head = prefixMap.headMap(key, true).descendingMap();
    Iterator<Entry<PrefixKey, CacheValue<Object>>> headItr = head.entrySet().iterator();
    Entry<PrefixKey, CacheValue<Object>> last = null;

    while (headItr.hasNext()) {
      Entry<PrefixKey, CacheValue<Object>> entry = headItr.next();
      if (isExpired(entry.getValue()) && key.isParent(entry.getKey())) {
        last = entry;
        headItr.remove();
      }
    }

    // If a list was removed, check its contained items for expiration.
    if (last != null) {
      SortedMap<PrefixKey, CacheValue<GoogleCloudStorageItemInfo>> prefix =
          getPrefixSubMap(itemMap, last.getKey());
      prefix.entrySet().removeIf(entry -> isExpired(entry.getValue()));
    }
  }
242456
public List<T> toSortedList() {
    List<T> sortedItems = Lists.newArrayList();
    while (size() > 0) {
      sortedItems.add(removeMin());
    }
    Collections.reverse(sortedItems);
    return sortedItems;
  }
98983
def removeAll(self):
        
        rv = self._removeAll(self._reads, self._writes)
        return rv