Returns a set of entries in this cache.
@return cache entries
326150
public Set<Entry<K, V>> entrySet() {
        TreeSet<Entry<K,V>> set = new TreeSet<Entry<K,V>>();
        
        synchronized( this ) {
            for(K key : keySet() ) {
                if( containsKey(key) ) {
                    get(key);
                    set.add(getEntry(key));
                }
            }
            return set;
        }
    }
733613
protected Set<E> set() {
    return elements.entrySet()
        .stream()
        .filter(entry -> !entry.getValue().isTombstone())
        .map(entry -> decode(entry.getKey()))
        .collect(Collectors.toSet());
  }
1116288
@Override
    @Synchronized
    public Set<Host> getClusterMembers() {
        if (!cache.isPresent()) {
            initializeCache();
        }
        List<ChildData> data = cache.get().getCurrentData();
        return data.stream()
                .map(d -> Host.fromBytes(d.getData()))
                .collect(Collectors.toSet());
    }
71944
function entries() {
  var result = []

  this.forEach(function(val, key) {
    result.push( [ key, val ] )
  })

  return result
}
944161
@Override
    public Set<Entry<String, GroovyRunner>> entrySet() {
        Map<String, GroovyRunner> map = getMap();
        readLock.lock();
        try {
            if (map.isEmpty()) {
                return Collections.emptySet();
            }
            return Collections.unmodifiableSet(new LinkedHashSet<>(map.entrySet()));
        } finally {
            readLock.unlock();
        }
    }
467565
public ArrayList<I> getInvocations()
  {
    LruCache<Object,I> invocationCache = _invocationCache;

    ArrayList<I> invocationList = new ArrayList<>();
      
    synchronized (invocationCache) {
      Iterator<I> iter;
      iter = invocationCache.values();

      while (iter.hasNext()) {
        invocationList.add(iter.next());
      }
    }

    return invocationList;
  }
1276968
public function entries()
    {
        $entries = array();

        if (false === $this->_entry_cache) {
            // cache is empty: fetch from LDAP
            while ($entry = $this->shiftEntry()) {
                $entries[] = $entry;
            }
            $this->_entry_cache = $entries; // store result in cache
        }

        return $this->_entry_cache;
    }
784125
public final Set<FilterEntry<T>> getFilterEntrys() {
        HashSet<FilterEntry<T>> set = new HashSet<>();
        set.addAll(entrys);
        if (ors != null) ors.forEach(f -> set.addAll(f.getFilterEntrys()));
        if (ands != null) ands.forEach(f -> set.addAll(f.getFilterEntrys()));
        return set;
    }
1093168
public Entries<K, V> entries () {
		if (entries == null)
			entries = new Entries(this);
		else
			entries.reset();
		return entries;
	}
1275839
@Override
    public Set<String> getCacheNames() {
        Set<String> names = new HashSet<>(this.cm.getCacheNames());
        names.add(this.defaultCache);
        return names;
    }
448219
@Override
    public Set<Entry<String, V>> entrySet() {
        HashMap<String, V> entries = new HashMap<>();
        entriesR(root.getLeft(), -1, entries);
        return entries.entrySet();
    }
971215
public Set<Map.Entry<Buffer, Buffer>> getAllParameters() {
        consumeUntil(null);
        if (this.paramMap != null) {
            return this.paramMap.entrySet();
        }
        return null;
    }
1187086
public Set<Map.Entry<K,V>> entrySet ()
    {
        // no modifying except through put() and remove()
        return Collections.unmodifiableSet(_delegate.entrySet());
    }
630930
@Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        final Set<Entry<K, V>> localSet = this.localMap.entrySet();

        if (isReadyOnly())
            return Collections.unmodifiableSet(localSet);

        return localSet;
    }
391412
public Set<Map.Entry<E,Double>> entrySet() {
    return new AbstractSet<Map.Entry<E,Double>>() {
      @Override
      public Iterator<Entry<E, Double>> iterator() {
        return new Iterator<Entry<E,Double>>() {
          final Iterator<Entry<E,MutableInteger>> inner = map.entrySet().iterator();

          public boolean hasNext() {
            return inner.hasNext();
          }

          public Entry<E, Double> next() {
            return new Map.Entry<E,Double>() {
              final Entry<E,MutableInteger> e = inner.next();

              public E getKey() {
                return e.getKey();
              }

              public Double getValue() {
                return e.getValue().doubleValue();
              }

              public Double setValue(Double value) {
                final double old = e.getValue().doubleValue();
                e.getValue().set(value.intValue());
                totalCount = totalCount - (int)old + value.intValue();
                return old;
              }
            };
          }

          public void remove() {
            throw new UnsupportedOperationException();
          }
        };
      }

      @Override
      public int size() {
        return map.size();
      }
    };
  }
637665
@SuppressWarnings("PMD.AvoidCatchingNPE")
  private Map<K, V> getAll(Set<? extends K> keys, boolean updateAccessTime) {
    requireNotClosed();
    boolean statsEnabled = statistics.isEnabled();
    long start = statsEnabled ? ticker.read() : 0L;
    try {
      Map<K, Expirable<V>> entries = getAndFilterExpiredEntries(keys, updateAccessTime);

      if (entries.size() != keys.size()) {
        List<K> keysToLoad = keys.stream()
            .filter(key -> !entries.containsKey(key))
            .collect(Collectors.<K>toList());
        entries.putAll(cache.getAll(keysToLoad));
      }

      Map<K, V> result = copyMap(entries);
      if (statsEnabled) {
        statistics.recordGetTime(ticker.read() - start);
      }
      return result;
    } catch (NullPointerException | IllegalStateException | ClassCastException | CacheException e) {
      throw e;
    } catch (RuntimeException e) {
      throw new CacheException(e);
    } finally {
      dispatcher.awaitSynchronous();
    }
  }
137907
public List<Pair<A, B>> getEntries() {
        List<Pair<A, B>> l = new ArrayList<>(size());
        for (Map.Entry<A, B> x : map1.entrySet())
            l.add(new Pair<>(x.getKey(), x.getValue()));
        return l;
    }