<p>
A list of inventory items on the instance(s).
</p>

@param entries
A list of inventory items on the instance(s).
@return Returns a reference to this object so that method calls can be chained together.
356371
public ListInventoryEntriesResult withEntries(java.util.Collection<java.util.Map<String, String>> entries) {
        setEntries(entries);
        return this;
    }
1073474
@SafeVarargs
    private static Map<CharSequence, Object> asMap(
        final Map.Entry<CharSequence, Object>... entries) {
        final Map<CharSequence, Object> map = new HashMap<>(entries.length);
        for (final Map.Entry<CharSequence, Object> ent : entries) {
            map.put(ent.getKey(), ent.getValue());
        }
        return map;
    }
402233
@Override
	public Set<Entry<Object, Object>> entrySet() {
		final Set<Entry<Object, Object>> entrySet = new HashSet<Entry<Object, Object>>();
		lock.readLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			for (final Map.Entry<Object, Object> keyEntry : getKeyMap(false).entrySet()) {
				final Object value = get(keyEntry.getValue(), useLocalPrefixes);
				if (String.class == keyEntry.getKey().getClass()) {
					entrySet.add(new PPEntry(keyEntry.getKey(), value));
				} else {
					entrySet.add(new PPEntry(keyEntry.getKey(), value));
				}
			}
			return entrySet;
		} finally {
			lock.readLock().unlock();
		}
	}
17245
private static Map<?, ?> mapOfEntries( Entry<?, ?>... entries ) {
        Map<Object, Object> looseTypedMap = new LinkedHashMap<>( entries.length );
        for (Entry<?, ?> entry : entries)
            looseTypedMap.put(entry.getKey(), entry.getValue());
        return looseTypedMap;
    }
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;
   }
1093168
public Entries<K, V> entries () {
		if (entries == null)
			entries = new Entries(this);
		else
			entries.reset();
		return entries;
	}
433101
public Set<Map.Entry<K, V>> entrySet() { 
       HashSet s = new HashSet(mBackingMap.size());
       for (Map.Entry e : mBackingMap.entrySet()) {
           if (mFilter.accept(e))
               s.add(e);
       }
       return s;
    }
659466
public java.util.List<KeyListEntry> getKeys() {
        if (keys == null) {
            keys = new com.amazonaws.internal.SdkInternalList<KeyListEntry>();
        }
        return keys;
    }
253580
public Set<String> entries() {
        Set<String> es = this.entries;
        if (es == null) {
            // lazily scan the entries
            this.entries = scan();
        }
        return this.entries;
    }
862136
public List<Entry> storeSkipExisting(List<Entry> entries) throws MissingParentException {
        List<Entry> skippedEntries = new LinkedList<Entry>();
        for (Entry e : entries) {
            try {
                store(e);
            } catch (EntryAlreadyExistsException ex) {
                skippedEntries.add(e);
            }
        }
        return skippedEntries;
    }
406371
public java.util.List<CustomKeyStoresListEntry> getCustomKeyStores() {
        if (customKeyStores == null) {
            customKeyStores = new com.amazonaws.internal.SdkInternalList<CustomKeyStoresListEntry>();
        }
        return customKeyStores;
    }
452768
public Iterable<Map.Entry<Integer, Record>> entries() {
        return () -> new Iterator<Map.Entry<Integer, Record>>() {
            private final Iterator<Map.Entry<Integer, Record>> it = data.records.entrySet().iterator();

            /** {@inheritDoc} */
            @Override
            public boolean hasNext() {
                return it.hasNext();
            }

            /** {@inheritDoc} */
            @Override
            public Map.Entry<Integer, Record> next() {
                return it.next();
            }

            /** {@inheritDoc} */
            @Override
            public void remove() {
                throw new UnsupportedOperationException("This is a read-only iterator, remove operation is not supported.");
            }
        };
    }
1362824
public ListSelectDialogBuilder<T> addListItems(T... items) {
        this.content.addAll(Arrays.asList(items));
        return this;
    }
1162050
public static <T> List<T> toList(Iterable<T> items) {
    List<T> list = new ArrayList<T>();
    addAll(list, items);
    return list;
  }
439012
public Set<java.util.Map.Entry<String, T>> entrySet()
	{
		return lookupMap.entrySet();
	}
519514
public static ValueIndex valueIndex(@NonNull ValueIndexItem... items) {
        if (items == null) {
            throw new IllegalArgumentException("items cannot be null.");
        }
        return new ValueIndex(items);
    }
600317
@SuppressWarnings("unchecked")
  @Deprecated
  public final List<E> getEntries() {
    List<E> result = new ArrayList<>(numEntries);
    for(Entry entry : entries) {
      if(entry != null) {
        result.add((E) entry);
      }
    }
    return result;
  }