* @throws NullPointerException if any element in the stream is {@code null}.
   * @return {@code Optional.of(onlyElement)} if the stream has exactly one element (must not be
   *     {@code null}) and returns {@code Optional.empty()} if it has none.
   */
  @SuppressWarnings("unchecked")
  public static <T> Collector<T, ?, Optional<T>> toOptional() {
    return (Collector) TO_OPTIONAL;
  }

			return nil, cred
		}
	}
	writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrAccessDenied), r.URL)
	return nil, auth.Credentials{}
}

// AdminError - is a generic error for all admin APIs.
type AdminError struct {
	Code       string
	Message    string
	StatusCode int
}

func (ae AdminError) Error() string {
	return ae.Message
}

            @Override
            public String getMailFromName() {
                return "Test Admin";
            }

            @Override
            public String getMailFromAddress() {
                return "******@****.***";
            }

            @Override
            public String getMailHostname() {
                return "localhost";
            }
        });

    }

    /**
     * Get the transform count
     *
     * @return number of transforms
     */
    public int getTransformCount() {
        return transformCount;
    }

    /**
     * Get the RDMA transform ID
     *
     * @return transform ID (should be 0x0001 for V1)
     */
    public int getRdmaTransformId() {

    return singleValue.equals(value);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {
    return ImmutableSet.of(immutableEntry(singleKey, singleValue));
  }

  @Override
  ImmutableSet<K> createKeySet() {
    return ImmutableSet.of(singleKey);
  }

    @Override
    public int getAttributes() {
        return fileAttributes;
    }

    @Override
    public long getCreateTime() {
        return lastWriteTime + serverTimeZoneOffset;
    }

    @Override
    public long getLastWriteTime() {
        return lastWriteTime + serverTimeZoneOffset;
    }

    @Override
    public long getSize() {
        return fileSize;
    }

    @Override

                            return s1.compareTo(s2);
                        } else {
                            return 0;
                        }
                    } else {
                        return v;
                    }
                } else {
                    return 0;
                }
            } else {
                return a;
            }
        }

            return parent.toArray();
        }

        public <T> T[] toArray(final T[] a) {
            return parent.toArray(a);
        }

        public boolean add(final E e) {
            return parent.add(e);
        }

        public boolean remove(final Object o) {
            return parent.remove(o);
        }

        public boolean containsAll(final Collection<?> c) {

		return true
	}
	return false
}

// IsLoong64RDTIME reports whether the op (as defined by an loong64.A*
// constant) is one of the RDTIMELW/RDTIMEHW/RDTIMED instructions that
// require special handling.
func IsLoong64RDTIME(op obj.As) bool {
	switch op {
	case loong64.ARDTIMELW, loong64.ARDTIMEHW, loong64.ARDTIMED:
		return true
	}
	return false
}

            }

            @Override
            public Locale getLocale() {
                return Locale.ENGLISH;
            }

            @Override
            public Object getAttribute(String name) {
                return null;
            }

            @Override
            public String[] getExtraQueries() {
                return new String[0];
            }