This ensures the specified CacheEntrys have not been invalidated.

@param cacheEntry The unfiltered CacheEntry.
@return The filtered CacheEntry.
768031
public CacheEntry filterEntry(String cacheName, CacheEntry cacheEntry) {
		
		InvalidationTableList invalidationTableList = getInvalidationTableList(cacheName);
		try {
			invalidationTableList.readWriteLock.readLock().lock();
			return internalFilterEntry(cacheName, invalidationTableList, cacheEntry);
		} finally {
			invalidationTableList.readWriteLock.readLock().unlock();
		}
	}
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());
            }
        }
    }
648063
public java.util.List<? extends com.google.javascript.jscomp.FunctionInformationMap.EntryOrBuilder> 
      getEntryOrBuilderList() {
    return entry_;
  }
66435
public RegistryEntry getEntry(String searchType) {
		for (Map.Entry<Class, RegistryEntry> entry : resources.entrySet()) {
			String type = getResourceType(entry.getKey());
			if (type == null) {
				return null;
			}
			if (type.equals(searchType)) {
				return entry.getValue();
			}
		}
		return null;
	}
27321
public synchronized void pushCacheEntry(CacheEntry cacheEntry, DCache cache) {
        BatchUpdateList bul = getUpdateList(cache);
        bul.pushCacheEntryEvents.add(cacheEntry);
    }
18004
@VisibleForTesting
    void removeAllCacheEntries() {
        List<CacheEntry> entries;
        synchronized (this.cacheEntries) {
            entries = new ArrayList<>(this.cacheEntries.values());
            this.cacheEntries.clear();
        }

        removeFromCache(entries);
        if (entries.size() > 0) {
            log.debug("{}: Cleared all cache entries ({}).", this.traceObjectId, entries.size());
        }
    }
885486
private CacheEntry toCacheEntry(final StackTraceElement stackTraceElement, final Class<?> callerClass,
                                    final boolean exact) {
        String location = "?";
        String version = "?";
        ClassLoader lastLoader = null;
        if (callerClass != null) {
            try {
                Bundle bundle = FrameworkUtil.getBundle(callerClass);
                if (bundle != null) {
                    location = bundle.getBundleId() + ":" + bundle.getSymbolicName();
                    version = bundle.getVersion().toString();
                }
            } catch (final Exception ex) {
                // Ignore the exception.
            }
            lastLoader = callerClass.getClassLoader();
        }
        return new CacheEntry(new ExtendedClassInfo(exact, location, version), lastLoader);
    }
1098307
public static <T> Response<T> success(T result, Cache.Entry cacheEntry) {
        return new Response<T>(result, cacheEntry);
    }
1188156
@Override
	public void cacheResult(CommerceSubscriptionEntry commerceSubscriptionEntry) {
		entityCache.putResult(CommerceSubscriptionEntryModelImpl.ENTITY_CACHE_ENABLED,
			CommerceSubscriptionEntryImpl.class,
			commerceSubscriptionEntry.getPrimaryKey(), commerceSubscriptionEntry);

		finderCache.putResult(FINDER_PATH_FETCH_BY_UUID_G,
			new Object[] {
				commerceSubscriptionEntry.getUuid(),
				commerceSubscriptionEntry.getGroupId()
			}, commerceSubscriptionEntry);

		finderCache.putResult(FINDER_PATH_FETCH_BY_C_C_C,
			new Object[] {
				commerceSubscriptionEntry.getCPInstanceUuid(),
				commerceSubscriptionEntry.getCProductId(),
				commerceSubscriptionEntry.getCommerceOrderItemId()
			}, commerceSubscriptionEntry);

		commerceSubscriptionEntry.resetOriginalValues();
	}
520551
public com.ibm.websphere.cache.CacheEntry getEntry(Object id) {
        return getEntry(id, CachePerf.LOCAL, IGNORE_COUNTING, !INCREMENT_REFF_COUNT);
    }
924734
final private com.ibm.websphere.cache.CacheEntry internal_putAndGet(
                                                                        Object key,
                                                                        Object value,
                                                                        Object userMetaData,
                                                                        int priority,
                                                                        int timeToLive,
                                                                        int inactivityTime,
                                                                        int sharingPolicy,
                                                                        Object dependencyIds[],
                                                                        Object aliasIds[],
                                                                        boolean incrementRefCount,
                                                                        boolean skipMemoryAndWriteToDisk) throws DynamicCacheException {

        final String methodName = "putAndGet(..)";
        ValidateUtility.objectNotNull(key, "key", value, "value");
        if (skipMemoryAndWriteToDisk && !cache.getSwapToDisk()) {
            throw new DiskOffloadNotEnabledException("DiskOffloadNotEnabledException occurred. The disk offload feature for cache instance \"" + cache.getCacheName()
                                                     + "\" is not enabled.");
        }
        if (skipMemoryAndWriteToDisk == true && sharingPolicy != EntryInfo.NOT_SHARED) {
            //DYNA1072W=DYNA1072W: The cache id \"{0}\" will not be replicated to other servers because \"skipMemoryWriteToDisk\" is set to true. The sharing policy will be set to \"not-shared\".
            Tr.warning(tc, "DYNA1072W", new Object[] { key });
            sharingPolicy = EntryInfo.NOT_SHARED;
        }
        ValidateUtility.sharingPolicy(sharingPolicy);
        if (sharingPolicy == EntryInfo.SHARED_PUSH_PULL ||
            sharingPolicy == EntryInfo.SHARED_PULL) {
            invalidate(key, true);
        }
        EntryInfo ei = entryInfoPool.allocate(key, dependencyIds, aliasIds);
        ei.setUserMetaData(userMetaData);
        ei.setPriority(priority);
        ei.setTimeLimit(timeToLive);
        ei.setSharingPolicy(sharingPolicy);
        ei.setInactivity(inactivityTime);
        CacheEntry ce = cacheEntryPool.allocate();
        ce.copyMetaData(ei);
        ce.setValue(value);
        ce.setSkipMemoryAndWriteToDisk(skipMemoryAndWriteToDisk);
        if (value instanceof DistributedNioMapObject) {
            ce.useByteBuffer = true;
        }
        // only put and no get for when skipMemoryAndWriteToDisk is true ==> refcount will not increment
        com.ibm.websphere.cache.CacheEntry newEntry = cache.setEntry(ce, CachePerf.LOCAL, false, Cache.COORDINATE, incrementRefCount);
        ei.returnToPool();

        try {

            if (cache.getCacheConfig().isDefaultCacheProvider()) {

                if (tc.isDebugEnabled()) {
                    if (newEntry != null) {
                        Tr.debug(tc, methodName + " " + cache.getCacheName() + " id=" + newEntry.getIdObject() + " incRefCount=" + incrementRefCount +
                                     " skipMemoryWriteToDisk=" + skipMemoryAndWriteToDisk);
                    }
                }

                if (ce.skipMemoryAndWriteToDisk) {
                    int errorCode = ce.skipMemoryAndWriteToDiskErrorCode;
                    StringBuffer message = new StringBuffer();
                    Exception ex = null;
                    switch (errorCode) {
                        case HTODDynacache.NO_EXCEPTION:
                            break;
                        case HTODDynacache.DISK_EXCEPTION:
                            message.append("The disk IO exception has occurred when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            ex = cache.getDiskCacheException();
                            if (ex != null) {
                                message.append(ex.getMessage());
                            }
                            throw new DiskIOException(message.toString());
                        case HTODDynacache.DISK_SIZE_OVER_LIMIT_EXCEPTION:
                            message.append("Exception has occurred either (1) there is no disk space available, or (2) the disk cache size in GB s over the (diskCacheSizeInGB) limit when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            ex = cache.getDiskCacheException();
                            if (ex != null) {
                                message.append(ex.getMessage());
                            }
                            throw new DiskSizeOverLimitException(message.toString());
                        case HTODDynacache.OTHER_EXCEPTION:
                            message.append("The runtime exception other than a Disk IOException has occurred when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            ex = cache.getDiskCacheException();
                            if (ex != null) {
                                message.append(ex.getMessage());
                            }
                            throw new MiscellaneousException(message.toString());
                        case HTODDynacache.SERIALIZATION_EXCEPTION:
                            message.append("The serialization exception has occurred when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            throw new SerializationException(message.toString());
                        case HTODDynacache.DISK_SIZE_IN_ENTRIES_OVER_LIMIT_EXCEPTION:
                            message.append("The disk cache size in entries is over the (diskCacheSize) limit when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            throw new DiskSizeInEntriesOverLimitException(message.toString());
                        case HTODDynacache.DISK_CACHE_ENTRY_SIZE_OVER_LIMIT_EXCEPTION:
                            message.append("The cache entry size is over the configured disk cache entry size (diskCacheEntrySizeInMB) limit when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            throw new DiskCacheEntrySizeOverLimitException(message.toString());
                    }
                }
            }
        } finally {
            ce.value = ce.serializedValue = null; //prevent ce.reset from Nio object release
            ce.returnToPool();
        }
        return newEntry;
    }
548147
@Override
	public void clearCache(CommerceSubscriptionEntry commerceSubscriptionEntry) {
		entityCache.removeResult(CommerceSubscriptionEntryModelImpl.ENTITY_CACHE_ENABLED,
			CommerceSubscriptionEntryImpl.class,
			commerceSubscriptionEntry.getPrimaryKey());

		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);

		clearUniqueFindersCache((CommerceSubscriptionEntryModelImpl)commerceSubscriptionEntry,
			true);
	}
914412
private static AvailEntry getAvailEntry(String key, ClassLoader loader) {
        return GET_AVAILABLE_CACHE.getInstance(key, loader);
    }
1319559
public ArrayList filterEntryList(String cacheName, ArrayList incomingList) {
		InvalidationTableList invalidationTableList = getInvalidationTableList(cacheName);
		try {
			invalidationTableList.readWriteLock.readLock().lock();
			Iterator it = incomingList.iterator();
			while (it.hasNext()) {
				Object obj = it.next();
				if (obj instanceof CacheEntry) {// ignore any "push-pull" String id's in DRS case
					CacheEntry cacheEntry = (CacheEntry) obj;
					if (internalFilterEntry(cacheName, invalidationTableList, cacheEntry) == null) {
						if (tc.isDebugEnabled()) {
							Tr.debug(tc, "filterEntryList(): Filtered OUT cacheName=" + cacheName + " id=" + cacheEntry.id);
						}
						it.remove();
					}
				}
			}
			return incomingList;

		} finally {
			invalidationTableList.readWriteLock.readLock().unlock();
		}
	}
164335
def get(self, entry):
        """"""
        try:
            list = self.cache[entry.key]
            return list[list.index(entry)]
        except:
            return None
834453
private int compareToLRU( CacheEntry other ) {

        int cmp = compareTime( other );
        if ( cmp != 0 ) {
            return cmp;
        }


        cmp = compareOrder( other );
        if ( cmp != 0 ) {
            return cmp;
        }


        return compareReadCount( other );
    }
655770
@Override
    public Set<QueryableEntry<K, V>> filter(QueryContext queryContext) {
        if (!(predicate instanceof IndexAwarePredicate)) {
            return null;
        }

        Set<QueryableEntry<K, V>> set = ((IndexAwarePredicate<K, V>) predicate).filter(queryContext);
        if (set == null || set.isEmpty()) {
            return set;
        }
        List<QueryableEntry<K, V>> resultList = new ArrayList<QueryableEntry<K, V>>();
        Map.Entry<Integer, Map.Entry> nearestAnchorEntry = getNearestAnchorEntry();
        for (QueryableEntry<K, V> queryableEntry : set) {
            if (SortingUtil.compareAnchor(this, queryableEntry, nearestAnchorEntry)) {
                resultList.add(queryableEntry);
            }
        }

        List<QueryableEntry<K, V>> sortedSubList =
                (List) SortingUtil.getSortedSubList((List) resultList, this, nearestAnchorEntry);
        return new LinkedHashSet<QueryableEntry<K, V>>(sortedSubList);
    }