* Settings are [connection][Http2Connection] scoped.
 */
class Settings {
  /** Bitfield of which flags that values. */
  private var set: Int = 0

  /** Flag values. */
  private val values = IntArray(COUNT)

  /** Returns -1 if unset. */
  val headerTableSize: Int
    get() {
      val bit = 1 shl HEADER_TABLE_SIZE
      return if (bit and set != 0) values[HEADER_TABLE_SIZE] else -1
    }

	ErrInvalidValueOfLength = errors.New("invalid association values, length doesn't match")
	// ErrPreloadNotAllowed preload is not allowed when count is used
	ErrPreloadNotAllowed = errors.New("preload is not allowed when count is used")
	// ErrDuplicatedKey occurs when there is a unique key constraint violation
	ErrDuplicatedKey = errors.New("duplicated key not allowed")

    public boolean setCount(T element, int oldCount, int newCount) {
      return standardSetCount(element, oldCount, newCount);
    }

    @Override
    public int setCount(T element, int count) {
      return standardSetCount(element, count);
    }

    @Override
    public Set<T> elementSet() {
      return new StandardElementSet();
    }

    @Override
    public Iterator<T> iterator() {

    CountingRunnable listener = new CountingRunnable();
    future.addListener(listener, directExecutor());
    assertEquals(1, listener.count);
  }

  private static final class CountingRunnable implements Runnable {
    int count;

    @Override
    public void run() {
      count++;
    }
  }

  @AndroidIncompatible // Mocking ExecutorService is forbidden there. TODO(b/218700094): Don't mock.

                setValue(e, key, value, now);
                newCount = this.count; // count remains unchanged
              } else {
                setValue(e, key, value, now);
                newCount = this.count + 1;
              }
              this.count = newCount; // write-volatile
              evictEntries(e);
              return null;

	flag.IntVar(&setCount, "set-count", 0, "Total set count")
	flag.IntVar(&shards, "shards", 0, "Total shards count")
	flag.BoolVar(&verbose, "v", false, "Display all objects")

	flag.Parse()

	if deploymentID == "" {
		log.Fatalln("deployment ID is mandatory")
	}

	if setCount == 0 {
		log.Fatalln("set count cannot be zero")
	}

	id := uuid.MustParse(deploymentID)

	// Set the split function for the scanning operation.
	scanner.Split(bufio.ScanWords)
	// Count the words.
	count := 0
	for scanner.Scan() {
		count++
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading input:", err)
	}
	fmt.Printf("%d\n", count)
	// Output: 15
}

// Use a Scanner with a custom split function (built by wrapping ScanWords) to validate

        // Source count is 10, but backup count will be different
        testClient.documentCount = 10;
        testClient.backupDocumentCount = 5;
        testClient.useBackupDocumentCount = true;

        final boolean result = testClient.reindexConfigIndices(false, allTargetPrefixes());

        assertFalse(result);
        // Backup indices should be cleaned up on count mismatch

	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}
		return err
	}

	count := 1
	v := strings.Split(key.Name, ":")
	if len(v) == 2 {
		count, err = strconv.Atoi(v[0])
		if err != nil {
			return err
		}
	}

	if err := h.send(context.Background(), eventData, count, h.payloadType, h.httpTimeout); err != nil {
		return err
	}

	// Delete the event from store.

  DescendingImmutableSortedMultiset(ImmutableSortedMultiset<E> forward) {
    this.forward = forward;
  }

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

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

  @Override
  public @Nullable Entry<E> lastEntry() {