*
   * @param keyFunction the function used to produce the key for each value
   * @return a map mapping the result of evaluating the function {@code keyFunction} on each value
   *     in this fluent iterable to that value
   * @throws IllegalArgumentException if {@code keyFunction} produces the same key for more than one
   *     value in this fluent iterable

   */
  public static <T> java.util.Optional<T> findLast(Stream<T> stream) {
    class OptionalState {
      boolean set = false;
      @CheckForNull T value = null;

      void set(T value) {
        this.set = true;
        this.value = value;
      }

      T get() {
        /*
         * requireNonNull is safe because we call get() only if we've previously called set().
         *

    EnumMapAccumulator(BinaryOperator<V> mergeFunction) {
      this.mergeFunction = mergeFunction;
    }

    void put(K key, V value) {
      if (map == null) {
        map = new EnumMap<>(singletonMap(key, value));
      } else {
        map.merge(key, value, mergeFunction);
      }
    }

    EnumMapAccumulator<K, V> combine(EnumMapAccumulator<K, V> other) {
      if (this.map == null) {

	psqlCreateAccessTable    = `CREATE TABLE %s (event_time TIMESTAMP WITH TIME ZONE NOT NULL, event_data JSONB);`

	psqlUpdateRow = `INSERT INTO %s (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value;`
	psqlDeleteRow = `DELETE FROM %s WHERE key = $1;`
	psqlInsertRow = `INSERT INTO %s (event_time, event_data) VALUES ($1, $2);`
)

// Postgres constants

  final R singleRowKey;
  final C singleColumnKey;
  final V singleValue;

  SingletonImmutableTable(R rowKey, C columnKey, V value) {
    this.singleRowKey = checkNotNull(rowKey);
    this.singleColumnKey = checkNotNull(columnKey);
    this.singleValue = checkNotNull(value);
  }

  SingletonImmutableTable(Cell<R, C, V> cell) {
    this(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
  }

  @Override

        @Override
        public String getAsString(final Object value) {
            if (value instanceof Date) {
                return DEFAULT_DATE_PRINTER.print(((Date) value).getTime());
            }
            return null;
        }

        @Override
        public Object getAsObject(final String value) {
            if (StringUtil.isEmpty(value)) {
                return null;
            }

}} - name: MINIO_ETCD_ENDPOINTS value: {{ join "," .Values.etcd.endpoints | quote }} {{- if .Values.etcd.clientCert }} - name: MINIO_ETCD_CLIENT_CERT value: "/etc/credentials/etcd_client_cert.pem" {{- end }} {{- if .Values.etcd.clientCertKey }} - name: MINIO_ETCD_CLIENT_CERT_KEY value: "/etc/credentials/etcd_client_cert_key.pem" {{- end }} {{- if .Values.etcd.pathPrefix }} - name: MINIO_ETCD_PATH_PREFIX value: {{ .Values.etcd.pathPrefix }} {{- end }} {{- if .Values.etcd.corednsPathPrefix }} - name:...

            val sortedContributors = contributorsToUpdate.entries.sortedBy { (it.value.name ?: it.key).toLowerCase() }
            val (linesBeforeContributors, _, linesAfterContributors) = parseReleaseNotes()
            releaseNotes.asFile.get().writeText(

    @Required
    @Size(max = 10000)
    public String term;

    @Required
    @Size(max = 10000)
    public String content;

    @Size(max = 1000)
    public String virtualHost;

    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer sortOrder;

    @Size(max = 1000)
    public String createdBy;

    @ValidateTypeFailure
    public Long createdTime;

 *
 * <p>This is needed because annotations can't implement interfaces, which is also why reflection is
 * used to extract values from the properties of the various annotations.
 *
 * @author George van den Driessche
 */
@Target(value = {ElementType.ANNOTATION_TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@GwtCompatible