Create a delta consisting of map entries.

@param entries
entries.

@return delta
173174
protected final MapDelta<K, V> genValues(final Map<K, ? extends V> entries) {
        return entries.isEmpty() ? Nop.instance() : new Values<>(entries);

    }
905786
@Override
  public Set<Map.Entry<K,V>> entrySet() {
    return new AbstractSet<Map.Entry<K,V>>() {
      @Override
      public Iterator<Map.Entry<K,V>> iterator() {
        Filter<Map.Entry<K,V>> filter1 = new Filter<Map.Entry<K,V>>() {
          private static final long serialVersionUID = 1L;

          // only accepts stuff not overwritten by deltaMap
          public boolean accept(Map.Entry<K,V> e) {
            K key = e.getKey();
            return ! deltaMap.containsKey(key);
          }
        };

        Iterator<Map.Entry<K, V>> iter1 = new FilteredIterator<Map.Entry<K, V>>(originalMap.entrySet().iterator(), filter1);

        Filter<Map.Entry<K,V>> filter2 = new Filter<Map.Entry<K,V>>() {
          private static final long serialVersionUID = 1L;
          // only accepts stuff not overwritten by deltaMap
          public boolean accept(Map.Entry<K,V> e) {
            Object value = e.getValue();
            if (value == removedValue) {
              return false;
            }
            return true;
          }
        };

        class NullingIterator<K, V> implements Iterator<Map.Entry<K,V>> {
          private Iterator<Map.Entry<K, V>> i;

          public NullingIterator(Iterator<Map.Entry<K, V>> i) {
            this.i = i;
          }

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

          public Map.Entry<K, V> next() {
            Map.Entry<K,V> e = i.next();
            Object o = e.getValue();
            if (o == nullValue) {
              return new SimpleEntry<K,V>(e.getKey(), null);
            }
            return e;
          }

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

        Iterator<Entry<K, V>> iter2 = new FilteredIterator<Entry<K,V>>(new NullingIterator<K, V>(deltaMap.entrySet().iterator()), filter2);

        return new ConcatenationIterator<Entry<K,V>>(iter1, iter2);
      }

      @Override
      public int size() {
        int size = 0;
        for (Entry<K, V> kvEntry : this) {
          ErasureUtils.noop(kvEntry);
          size++;
        }
        return size;
      }
    };
  }
909023
private List<Data> getKeyValueSequence(Map<?, ?> entries) {
        if (entries == null || entries.isEmpty()) {
            return Collections.emptyList();
        }
        List<Data> keyValueSequence = new ArrayList<>(entries.size() * 2);
        for (Map.Entry<?, ?> entry : entries.entrySet()) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            Data dataKey = mapServiceContext.toData(key);
            Data dataValue = mapServiceContext.toData(value);
            keyValueSequence.add(dataKey);
            keyValueSequence.add(dataValue);
        }
        return keyValueSequence;
    }
517316
public static <K, V> Map<K, V> leftShift(Map<K, V> self, Map.Entry<K, V> entry) {
        self.put(entry.getKey(), entry.getValue());
        return self;
    }
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;
	}
783948
@Override public ImmutableSet<Entry<K, V>> entries() {
    ImmutableSet<Entry<K, V>> result = entries;
    return (result == null)
        ? (entries = new EntrySet<K, V>(this))
        : result;
  }
267506
public static <L, R> @NonNull Pair<L, R> of(final Map.Entry<L, R> entry) {
    return of(entry.getKey(), entry.getValue());
  }
951236
public static <K, V> HashMap<K, V> newHashMap(@NotNull final K[] keys, @NotNull final V[] values) {
		Validate.isTrue(keys.length == values.length, "keys.length is %d but values.length is %d", keys.length,
				values.length);

		HashMap<K, V> map = new HashMap<K, V>(keys.length * 2);

		for (int i = 0; i < keys.length; i++) {
			map.put(keys[i], values[i]);
		}

		return map;
	}
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();
	    }
	};
    }
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;
	}
26991
@Override
  public Set<Map.Entry<String, List<String>>> entrySet() {
    return getMap().entrySet();
  }
1017571
protected final void doValues(final Map<K, ? extends V> entries) {
        apply(entries.isEmpty() ? Nop.instance() : new Values<>(entries));

    }
29420
public Iterator<Map.Entry<T,Double>> iterator() {
        return Collections.unmodifiableSet(
            TDecorators.wrap(counts).entrySet()).iterator();
    }
439012
public Set<java.util.Map.Entry<String, T>> entrySet()
	{
		return lookupMap.entrySet();
	}
95294
public static void pack(ZipEntrySource[] entries, File zip) {
    if (log.isDebugEnabled()) {
      log.debug("Creating '{}' from {}.", zip, Arrays.asList(entries));
    }

    OutputStream out = null;
    try {
      out = new BufferedOutputStream(new FileOutputStream(zip));
      pack(entries, out, true);
    }
    catch (IOException e) {
      throw ZipExceptionUtil.rethrow(e);
    }
    finally {
      IOUtils.closeQuietly(out);
    }
  }
357408
@Override
    public Set<java.util.Map.Entry<Long, V>> entrySet() {
        return this.timeSeriesMap.entrySet();
    }
408531
@SafeVarargs
    private static Map<Pattern, Pass> asMap(
        final Map.Entry<Pattern, Pass>... entries) {
        final Map<Pattern, Pass> map = new HashMap<>(entries.length);
        for (final Map.Entry<Pattern, Pass> ent : entries) {
            map.put(ent.getKey(), ent.getValue());
        }
        return map;
    }