}

  private static int totalSize(Iterable<? extends Entry<?>> entries) {
    int sum = 0;
    for (Entry<?> entry : entries) {
      sum += entry.getCount();
    }
    return sum;
  }

  private enum SubMultisetSpec {
    TAIL_CLOSED {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntry, List<Entry<E>> entries) {
        return entries.subList(targetEntry, entries.size());
      }

      val result = runCatching { call.execute().body.bytes() }

      if (testItFails) {
        assertThat(result).isFailure()
      } else {
        result.getOrThrow()
      }
    }
  }

  enum class OverrideParam(
    val override: Override<*>,
  ) {
    Authenticator(Override.AuthenticatorOverride),
    Cache(Override.CacheOverride),
    CertificatePinner(Override.CertificatePinnerOverride),

      }
      return ImmutableMap.copyOf(map);
    }
  }

  /**
   * Any updates to LocalCache.Strength used in CacheBuilder need to be matched in this class for
   * compilation purposes.
   */
  enum Strength {
    /*
     * TODO(kevinb): If we strongly reference the value and aren't loading, we needn't wrap the
     * value. This could save ~8 bytes per entry.
     */

    STRONG {
      @Override

        public StatsCounter get() {
          return new SimpleStatsCounter();
        }
      };

  enum NullListener implements RemovalListener<Object, Object> {
    INSTANCE;

    @Override
    public void onRemoval(RemovalNotification<Object, Object> notification) {}
  }

  enum OneWeigher implements Weigher<Object, Object> {
    INSTANCE;

    @Override

        }
    }

    /**
     * Enumeration of different artifact types supported by Fess.
     * Each type has a specific ID prefix used to identify artifacts of that type.
     */
    public enum ArtifactType {
        /** Data store plugins */
        DATA_STORE("fess-ds"), //
        /** Theme plugins */
        THEME("fess-theme"), //
        /** Ingest processor plugins */

 */
public class SmbCircuitBreaker {

    private static final Logger log = LoggerFactory.getLogger(SmbCircuitBreaker.class);

    /**
     * Circuit breaker states
     */
    public enum State {
        /**
         * Normal operation - requests pass through
         */
        CLOSED,

        /**
         * Service is failing - requests are blocked
         */
        OPEN,

### Bir `Enum` Sınıfı Oluşturalım { #create-an-enum-class }

`Enum`'u import edin ve `str` ile `Enum`'dan miras alan bir alt sınıf oluşturun.

   * char[])}.
   *
   * @since 2.0
   */
  public static Comparator<char[]> lexicographicalComparator() {
    return LexicographicalComparator.INSTANCE;
  }

  private enum LexicographicalComparator implements Comparator<char[]> {
    INSTANCE;

    @Override
    public int compare(char[] left, char[] right) {
      int minLength = Math.min(left.length, right.length);

      if (newArg == null || Objects.equals(args.get(i), newArg)) {
        if (params.get(i).getType().getRawType().isEnum()) {
          continue; // Nothing better we can do if it's single-value enum
        }
        throw new ParameterHasNoDistinctValueException(params.get(i));
      }
      newArgs.set(i, newArg);
      tester.addEqualityGroup(createInstance(factory, newArgs));

     */
    public ApiResult(final ApiResponse response) {
        this.response = response;
    }

    /**
     * Represents the status of an API response.
     */
    public enum Status {
        /** Successful response status. */
        OK(0),
        /** Bad request status indicating client error. */
        BAD_REQUEST(1),
        /** System error status indicating server error. */