/**
 * Abstract interface for objects that can concurrently add longs.
 *
 * @author Louis Wasserman
 */
interface LongAddable {
  void increment();

  void add(long x);

  long sum();

  ) {
    val builder = "http://host/".toHttpUrl().newBuilder()
    component[builder] = codePointString
    val url = builder.build()
    assertThat(url.host).startsWith(Punycode.PREFIX_STRING)
  }

  enum class Encoding {
    IDENTITY {
      override fun encode(codePoint: Int): String = String(codePoint)
    },
    PERCENT {
      override fun encode(codePoint: Int): String {

 *
 * @author Osvaldo Doederlein
 */
@NullUnmarked
public class ToStringHelperBenchmark {

  @Param({"0", "1", "5"})
  int dataSize;

  @Param({"false", "true"})
  boolean omitNulls;

  enum Dataset {
    SMALL {
      @Override
      void addEntries(MoreObjects.ToStringHelper helper) {
        helper
            .add(SHORT_NAME, 10)
            .addValue(10L)
            .add(SHORT_NAME, 3.14f)

 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Resolution {

    /**
     * The id of a {@link org.apache.maven.api.PathScope} enum value.
     * If specified, a dependency resolution request will be issued,
     * else a dependency collection request will be done.
     *
     * @return the id of the path scope
     */

     */
    public static StorageClient createClient() {
        return createClient(ComponentUtil.getFessConfig());
    }

    /**
     * Parses a storage type string to StorageType enum.
     *
     * @param typeStr the type string (s3, gcs, s3_compat, auto)
     * @return parsed StorageType
     */
    private static StorageType parseStorageType(final String typeStr) {

                (biMap, o) -> {
                  Object unused = biMap.inverse().get(o);
                },
                Math::log)));
  }

  /** All the ways to create an ImmutableBiMap. */
  enum ConstructionPathway {
    COPY_OF_MAP {
      @Override
      public ImmutableBiMap<Object, Object> create(List<Entry<?, ?>> entries) {
        Map<Object, Object> sourceMap = new LinkedHashMap<>();

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

class Graph {
    private enum DfsState {
        VISITING,
        VISITED
    }

    final Map<String, Vertex> vertices = new LinkedHashMap<>();

    public Vertex getVertex(String id) {
        return vertices.get(id);
    }

    private static final long serialVersionUID = 1L;
    private static final Logger log = LoggerFactory.getLogger(SmbOperationException.class);

    /**
     * Error categories for SMB operations
     */
    public enum ErrorCategory {
        /** Network-related errors (connection, timeout, etc.) */
        NETWORK,
        /** Authentication and authorization errors */
        AUTHENTICATION,

   * <p>The ordering of the {@link State} enum is defined such that if there is a state transition
   * from {@code A -> B} then {@code A.compareTo(B) < 0}. N.B. The converse is not true, i.e. if
   * {@code A.compareTo(B) < 0} then there is <b>not</b> guaranteed to be a valid state transition
   * {@code A -> B}.
   *
   * @since 9.0 (in 1.0 as {@code com.google.common.base.Service.State})
   */
  enum State {

 * by specific provider implementations.
 */
public abstract class RdmaConnection implements AutoCloseable {

    /**
     * RDMA connection state enumeration
     */
    public enum RdmaConnectionState {
        /** Connection is not established */
        DISCONNECTED,
        /** Connection is being established */
        CONNECTING,