Returns all the mappings in the state in a {@link Collections#unmodifiableSet(Set)}.

@return A read-only iterable view of all the key-value pairs in the state.
556359
@Override
	public Iterable<Map.Entry<K, V>> entries() {
		return Collections.unmodifiableSet(state.entrySet());
	}
1040012
public Set<String> keySet(){
		HashSet<String> set=new HashSet<String>();
		Iterator<String> keys=keys();
		while(keys.hasNext()){
			set.add(keys.next());
		}
		return set;
	}
389078
public static <K, V> ImmutableSet<K> allKeys(final Iterable<? extends Map<K, V>> maps) {
    final ImmutableSet.Builder<K> builder = ImmutableSet.builder();

    for (final Map<K, V> map : maps) {
      builder.addAll(map.keySet());
    }

    return builder.build();
  }
898068
public Set<ElementDescriptor<?>> getProperties()
	{
		return mProp == null ? null : Collections.unmodifiableSet(mProp.keySet());
	}
891429
@Override
    public Collection<V> values() {
        final Collection<V> localValues = this.localMap.values();

        if (isReadyOnly())
            return Collections.unmodifiableCollection(localValues);

        return localValues;
    }
810554
public Set<Annotation> getPropertyAnnotations()
	{
		if (accessor instanceof PropertyAwareAccessor)
		{
			return unmodifiableSet(((PropertyAwareAccessor) accessor).getReadMethodAnnotations());
		}
		return unmodifiableSet(Collections.<Annotation>emptySet());
	}
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();
        }
    }
499043
public Set<Map.Entry<A,B>> entrySet() {
	return new AbstractSet<Map.Entry<A,B>>() {
	    public int size() {
		return map.size();
	    }
	    public Iterator<Map.Entry<A,B>> iterator() {
		return new Iterator<Map.Entry<A,B>>() {
		    private final Iterator<Map.Entry<A,B>> it = map.entrySet().iterator();
		    private Map.Entry<A,B> last = null;
		    public boolean hasNext() {
			return it.hasNext(); 
		    }
		    public Map.Entry<A,B> next() { 
		        last = it.next();
			return last;
		    }
		    public void remove() {
			it.remove();
			revMap.remove(last.getValue());
		    }
		};
	    }
	    public boolean remove(Object o) {
		if(!(o instanceof Map.Entry/*<A,B>*/)) return false;
		@SuppressWarnings("unchecked")
		Map.Entry<A,B> entry = (Map.Entry<A,B>) o;
		B currValue = BijMap.this.get(entry.getKey());
		if((currValue == null) || !currValue.equals(entry.getValue())) return false;
		BijMap.this.remove(entry.getKey());
		return true;
	    }
	    public void clear() {
		BijMap.this.clear();
	    }
	};
    }
1256720
public Set<Map.Entry<String, CacheEntry>> entrySet() {
		Set<Map.Entry<String, CacheEntry>> result = Collections.emptySet();
		NavigableMap<String, CacheEntry> navMap = new TreeMap<String, CacheEntry>(map);
		String from = navMap.ceilingKey(keyPrefix), to = navMap.lowerKey(keyPrefixUpperBound);
		if (from != null) {
			result = navMap.subMap(from, true, to, true).entrySet();
		}
		return result;
	}
7588
public Set<Map.Entry<String, String>> getSetEntries() {
      Set<Map.Entry<String, String>> entries = optionSet.stream()
                                                        .filter(this::isSet)
                                                        .map(no -> Tuple2.of(no.getName(),
                                                                             Convert.convert(no.getValue(),
                                                                                             String.class)))
                                                        .collect(Collectors.toSet());
      entries.addAll(unamedOptions.entrySet());
      return entries;
   }
993119
public static <K> ImmutableSet<K> allMultimapKeys(final Iterable<? extends Multimap<K, ?>> multimaps) {
    final ImmutableSet.Builder<K> builder = ImmutableSet.builder();

    for (final Multimap<K, ?> multimap : multimaps) {
      builder.addAll(multimap.keySet());
    }

    return builder.build();
  }
240756
public Set<String> keySet() {

        PropertyBundle p = this;
        Set<String> keys = new HashSet<>(p.key2values.keySet());

        while ((p = p.parent) != null) {
            keys.addAll(p.key2values.keySet());
        }

        return Collections.unmodifiableSet(keys);

    }
184873
public static final <K,V> MapSet<K,V> unmodifiableMapSet(MapSet<K,V> set)
    {
        return new UnmodifiableMapSet(set);
    }
344012
public static <K, V> Map<K, V> unmodifiableCopy(
        Map<? extends K, ? extends V> map)
    {
        return Collections.<K, V>unmodifiableMap(
            new LinkedHashMap<K, V>(map));
    }
774134
@Override
    public Set<Map.Entry<String, Object>> entrySet() {
        return Collections.unmodifiableSet(new AbstractSet<Map.Entry<String, Object>>() {
            @Override
            public Iterator<Map.Entry<String, Object>> iterator() {
                return entryIterator();
            }

            @Override
            public int size() {
                return BeanMap.this.types.size();
            }
        });
    }
1195863
public Set<String> absentKeysOrValues() {
		return underlyingMap.entrySet()
			.stream()
			.filter(LinkedOptionalMap::keyOrValueIsAbsent)
			.map(Entry::getKey)
			.collect(Collectors.toCollection(LinkedHashSet::new));
	}
544270
public synchronized Collection<String> getNames() {
        if (map == null) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(new HashMap<String,String>(map).keySet());
    }