/*
(non-Javadoc)

@see java.util.Map#entrySet()
357408
@Override
    public Set<java.util.Map.Entry<Long, V>> entrySet() {
        return this.timeSeriesMap.entrySet();
    }
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();
	    }
	};
    }
1068409
public Set<K> keySet()
  {
    if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.entry(this, _tc, "keySet");
    
    UnsupportedOperationException uoe = new UnsupportedOperationException();
    
    if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.exit(this, _tc, "keySet", uoe);
    throw uoe;
  }
17034
public Entries<K, V> entries () {
		if (entries1 == null) {
			entries1 = new OrderedMapEntries(this);
			entries2 = new OrderedMapEntries(this);
		}
		if (!entries1.valid) {
			entries1.reset();
			entries1.valid = true;
			entries2.valid = false;
			return entries1;
		}
		entries2.reset();
		entries2.valid = true;
		entries1.valid = false;
		return entries2;
	}
397724
public Set<Key> keySet(int access) {

	Set<Key> set = new LinkedHashSet<Key>();
	Map.Entry<Key, Member> entry;
	Iterator<Entry<Key, Member>> it = _data.entrySet().iterator();
	while (it.hasNext()) {
	    entry = it.next();
	    if (entry.getValue().getAccess() <= access) set.add(entry.getKey());
	}
	return set;
    }
940962
@SafeVarargs
   public static <T> Set<T> makeSet(T... entries) {
      return new HashSet<>(Arrays.asList(entries));
   }
909658
public static <K, V> EntryStream<K, V> of(Map<K, V> map) {
        return of(map.entrySet().stream());
    }
472651
@Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        try {
            lockAllSegments();
            Set<java.util.Map.Entry<K, V>> set = new HashSet<>();
            for (LinkedHashMapSegment<K, V> seg : segments) {
                set.addAll(seg.entrySet());
            }
            return set;
        } finally {
            unlockAllSegments();
        }
    }
1065154
@Override
	public boolean isEmpty() {
		lock.readLock().lock();
		try {
			return entrySet().isEmpty();
		} finally {
			lock.readLock().unlock();
		}
	}
600042
@Override
  public Set<java.util.Map.Entry<String, String>> entrySet() {
    return bindings.entrySet();
  }
994739
public void doesNotContainEntry(@NullableDecl Object key, @NullableDecl Object value) {
    checkNoNeedToDisplayBothValues("entrySet()")
        .that(actual().entrySet())
        .doesNotContain(immutableEntry(key, value));
  }
1187086
public Set<Map.Entry<K,V>> entrySet ()
    {
        // no modifying except through put() and remove()
        return Collections.unmodifiableSet(_delegate.entrySet());
    }
455228
protected Set<Entry<ADDRESST, EventListener>> listenersEntrySet() {
		final Object mutex = mutex();
		synchronized (mutex) {
			return Collections3.synchronizedSet(this.listeners.entrySet(), mutex);
		}
	}
34047
public synchronized Set<java.util.Map.Entry<String, XAttribute>> entrySet() {
		if(backingStore != null) {
			return backingStore.entrySet();
		} else {
			return EMPTY_ENTRYSET;
		}
	}
589626
@Override
    public Set<Map.Entry<K, V>> entrySet() {
        return new AbstractSet<Map.Entry<K, V>>() {
            @Override
            public Iterator<Map.Entry<K, V>> iterator() {
                return new ObjIterator<Map.Entry<K, V>>() {
                    private final Iterator<Map.Entry<K, V>> keyValueEntryIter = keyMap.entrySet().iterator();

                    @Override
                    public boolean hasNext() {
                        return keyValueEntryIter.hasNext();
                    }

                    @Override
                    public Map.Entry<K, V> next() {
                        final Map.Entry<K, V> entry = keyValueEntryIter.next();

                        return new Map.Entry<K, V>() {
                            @Override
                            public K getKey() {
                                return entry.getKey();
                            }

                            @Override
                            public V getValue() {
                                return entry.getValue();
                            }

                            @Override
                            public V setValue(V value) {
                                //    if (N.equals(entry.getValue(), value)) {
                                //        return entry.getValue();
                                //    }
                                //
                                //    //    if (valueMap.containsKey(value)) {
                                //    //        throw new IllegalStateException("Value: " + N.toString(value) + " already existed.");
                                //    //    }
                                //
                                //    valueMap.remove(entry.getValue());
                                //    valueMap.put(value, entry.getKey());
                                //    return entry.setValue(value);

                                throw new UnsupportedOperationException();
                            }
                        };
                    }
                };
            }

            @Override
            public int size() {
                return keyMap.size();
            }
        };
    }
600071
public JPAEntry getEntry(String entryKey) {
        for (JPAEntry entry : entries) {
            if (entry.getKey().equals(entryKey)) {
                return entry;
            }
        }
        return null;
    }
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;
    }