}

  private int getCount(int index) {
    return (int) (cumulativeCounts[offset + index + 1] - cumulativeCounts[offset + index]);
  }

  @Override
  Entry<E> getEntry(int index) {
    return Multisets.immutableEntry(elementSet.asList().get(index), getCount(index));
  }

  @Override
  @CheckForNull
  public Entry<E> firstEntry() {
    return isEmpty() ? null : getEntry(0);
  }

  @Override

      for (String element : elements) {
        builder.add(element);
      }
      return builder.build();
    }
  }

  public static class BuilderAddAllListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.<String>builder().addAll(asList(elements)).build();
    }
  }

            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });
        return asJson(

     * @param mode
     *            モード。{@literal null}であってはいけません
     * @return ファイルチャネルをメモリにマップした{@link ByteBuffer}
     */
    public static ByteBuffer map(final FileChannel channel, final MapMode mode) {
        assertArgumentNotNull("channel", channel);
        assertArgumentNotNull("mode", mode);

        try {
            return channel.map(mode, 0, channel.size());
        } catch (final IOException e) {

  @Override
  public int count(@CheckForNull Object element) {
    return forward.count(element);
  }

  @Override
  @CheckForNull
  public Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  @CheckForNull
  public Entry<E> lastEntry() {
    return forward.firstEntry();
  }

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

  @Override

     * @param selectedMech
     * @return whether the specified mechanism is preferred
     */
    boolean isPreferredMech ( ASN1ObjectIdentifier selectedMech );


    /**
     * @return context flags
     */
    int getFlags ();


    /**
     * @return array of supported mechanism OIDs
     */
    ASN1ObjectIdentifier[] getSupportedMechs ();


    /**
     * 

    public Object get(final String key) {
        return params.get(key);
    }

    public String getAsString(final String key) {
        if (params.get(key) instanceof final String strValue) {
            return strValue;
        }
        final Object value = params.get(key);
        if (value != null) {
            return value.toString();
        }
        return null;
    }

            this.session = session;
            return this;
        }

        public ProjectBuilderRequestBuilder path(Path path) {
            this.path = path;
            return this;
        }

        public ProjectBuilderRequestBuilder source(Source source) {
            this.source = source;
            return this;
        }

	cause      error
}

func (err *s3Error) Cause() error {
	return err.cause
}

func (err *s3Error) ErrorCode() string {
	return err.code
}

func (err *s3Error) ErrorMessage() string {
	return err.message
}

func (err *s3Error) HTTPStatusCode() int {
	return err.statusCode
}

func (err *s3Error) Error() string {
	return err.message
}

func errMalformedXML(err error) *s3Error {

            return isIncubatingField((JApiField) member)
        }
        if (member instanceof JApiConstructor) {
            return isIncubatingConstructor((JApiConstructor) member)
        }
        return isAnnotatedWithIncubating(member)
    }

    private static boolean isIncubatingClass(JApiClass clazz) {
        return isAnnotatedWithIncubating(clazz)
    }