/**
     * インデックスで指定された位置のキーを返します。
     *
     * @param index
     *            インデックス
     * @return インデックスで指定された位置のキー
     */
    public K getKeyAt(final int index) {
        return getEntryAt(index).getKey();
    }

    /**
     * インデックスで指定された位置の{@link java.util.Map.Entry}を返します。
     *
     * @param index
     *            インデックス
     * @return インデックスで指定された位置の{@link java.util.Map.Entry}
     */

            new TestStringMapGenerator() {
              @Override
              protected Map<String, String> create(Entry<String, String>[] entries) {
                return singletonMap(entries[0].getKey(), entries[0].getValue());
              }
            })
        .named("singletonMap")
        .withFeatures(
            MapFeature.ALLOWS_NULL_KEYS,
            MapFeature.ALLOWS_NULL_VALUES,

   */
  public char[] @Nullable [] toArray() {
    char[][] result = new char[max + 1][];
    for (Entry<Character, String> entry : map.entrySet()) {
      result[entry.getKey()] = entry.getValue().toCharArray();
    }
    return result;
  }

  /**
   * Convert this builder into a char escaper which is just a decorator around the underlying array
   * of replacement char[]s.

    }

    Entry<K, V> getEntry(final int index) {
      checkElementIndex(index, size());
      return new AbstractMapEntry<K, V>() {
        @Override
        public K getKey() {
          return ArrayMap.this.getKey(index);
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override

    assertNull("put(null, null) should return null", put(nullKeyValueEntry));
    expectAdded(nullKeyValueEntry);
  }

  @CanIgnoreReturnValue
  private V put(Entry<K, V> entry) {
    return getMap().put(entry.getKey(), entry.getValue());
  }

  /**
   * Returns the {@link Method} instance for {@link #testPut_nullKeyUnsupported()} so that tests of
   * {@link java.util.TreeMap} can suppress it with {@code

    public <T extends B> Builder<B> putAll(Map<? extends Class<? extends T>, ? extends T> map) {
      for (Entry<? extends Class<? extends T>, ? extends T> entry : map.entrySet()) {
        Class<? extends T> type = entry.getKey();
        T value = entry.getValue();
        mapBuilder.put(type, cast(type, value));
      }
      return this;
    }

    private static <T> T cast(Class<T> type, Object value) {

                                                                logger.debug("Skipping interpolation of field: " + field
                                                                        + " (key: " + entry.getKey() + ") in: "
                                                                        + cls.getName()
                                                                        + "; it is an unmodifiable collection.");

    }


    @Override
    public void setLink ( String link ) {
        this.link = link;
    }


    /**
     * @return the key
     */
    @Override
    public String getKey () {
        return this.key;
    }


    /**
     * @param key
     *            the key to set
     */
    @Override
    public void setKey ( String key ) {
        this.key = key;

        private BiEntry<K, V> delegate;

        MapEntry(BiEntry<K, V> entry) {
          this.delegate = entry;
        }

        @Override
        @ParametricNullness
        public K getKey() {
          return delegate.key;
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return delegate.value;
        }

        @Override

    for (p in properties) {
        when (jvmSignature) {
            p.fieldSignature?.toString() -> return predicate.match(p)
            p.getterSignature?.toString() -> return predicate.match(p.getter)
            p.setterSignature?.toString() -> return p.setter?.let { predicate.match(it) } ?: false
        }
    }
    return false
}

interface AttributePredicate {