}

  private final transient Map<K, V> delegateMap;
  private final transient ImmutableList<Entry<K, V>> entries;

  JdkBackedImmutableMap(Map<K, V> delegateMap, ImmutableList<Entry<K, V>> entries) {
    this.delegateMap = delegateMap;
    this.entries = entries;
  }

  @Override
  public int size() {
    return entries.size();
  }

  @Override
  @CheckForNull
  public V get(@CheckForNull Object key) {

        if (!prefix.equals("") && current.entries.size() < maxChildIndexEntries / 2) {
            throw new IOException(String.format("Too few entries found in %s", current));
        }
        if (current.entries.size() > maxChildIndexEntries) {
            throw new IOException(String.format("Too many entries found in %s", current));
        }

            // for MapProperty allows a provider to override the entries of earlier providers and so there can be multiple entries
            // with the same key
            Map<K, V> entries = new LinkedHashMap<>();
            Value<Void> result = collector.collectEntries(consumer, entryCollector, entries);
            if (result.isMissing()) {

  }

  private Entry<K, V>[] getEntriesMultipleNonNullKeys() {
    Entry<K, V>[] entries = createSamplesArray();
    entries[0] = entry(k1(), v0());
    return entries;
  }

  private void expectFirstRemoved(Entry<K, V>[] entries) {
    resetMap(entries);

    List<Entry<K, V>> expectedWithDuplicateRemoved =
        Arrays.asList(entries).subList(1, getNumElements());
    expectContents(expectedWithDuplicateRemoved);
  }

type readDirOpts struct {
	// The maximum number of entries to return
	count int
	// Follow directory symlink
	followDirSymlink bool
}

// Return all the entries at the directory dirPath.
func readDir(dirPath string) (entries []string, err error) {
	return readDirWithOpts(dirPath, readDirOpts{count: -1})
}

// Return up to count entries at the directory dirPath.

      Set<Entry<Object, Object>> entries = cache.asMap().entrySet();
      List<Entry<Object, Object>> warmed = warmUp(cache, WARMUP_MIN, WARMUP_MAX);

      Set<?> expected = Maps.newHashMap(cache.asMap()).entrySet();
      assertThat(entries).containsExactlyElementsIn(expected);
      assertThat(entries.toArray()).asList().containsExactlyElementsIn(expected);

  @VisibleForTesting final transient Entry<K, V>[] entries;
  private final transient int mask;
  private final transient int hashCode;

  static <K, V> ImmutableBiMap<K, V> fromEntries(Entry<K, V>... entries) {
    return fromEntryArray(entries.length, entries);
  }

  static <K, V> ImmutableBiMap<K, V> fromEntryArray(int n, @Nullable Entry<K, V>[] entryArray) {

		} else {
			attributeNames.Insert(attributeName)
		}

		entries := sets.New[string]()
		if attribute.QuantityValue != nil {
			entries.Insert("quantity")
		}
		if attribute.BoolValue != nil {
			entries.Insert("bool")
		}
		if attribute.IntValue != nil {
			entries.Insert("int")
		}
		if attribute.IntSliceValue != nil {
			entries.Insert("intSlice")
		}
		if attribute.StringValue != nil {

type Bar struct {
	baz	*Baz
	foo	[]*Foo
}

type Baz struct {
	entries		map[int]interface{}
	whatever	string
}

func newFoo() *Foo {
	return &Foo{bar: &Bar{baz: &Baz{
		entries: map[int]interface{}{
			42:	&Foo{},
			21:	&Bar{},
			11:	&Baz{whatever: "it's just a test"}}}},
		bang: &Bar{foo: []*Foo{
			&Foo{bar: &Bar{baz: &Baz{
				entries: map[int]interface{}{
					43:	&Foo{},
					22:	&Bar{},

	b.ensureObjectMetaApplyConfigurationExists()
	if b.Labels == nil && len(entries) > 0 {
		b.Labels = make(map[string]string, len(entries))
	}
	for k, v := range entries {
		b.Labels[k] = v
	}
	return b
}

// WithAnnotations puts the entries into the Annotations field in the declarative configuration