public void testImmutableEntrySerialization() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    SerializableTester.reserializeAndAssert(entry);
  }

  public void testImmutableEntryToString() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    assertThat(entry.toString()).isEqualTo("(foo,1)=a");

    Cell<@Nullable String, @Nullable Integer, @Nullable Character> nullEntry =

    int[] cellRowIndices = new int[cellList.size()];
    int[] cellColumnIndices = new int[cellList.size()];
    for (int i = 0; i < cellList.size(); i++) {
      Cell<R, C, V> cell = cellList.get(i);
      R rowKey = cell.getRowKey();
      C columnKey = cell.getColumnKey();
      // The requireNonNull calls are safe because we construct the indexes with indexMap.
      int rowIndex = requireNonNull(rowKeyToIndex.get(rowKey));

    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
  public ImmutableMap<R, V> column(C columnKey) {
    checkNotNull(columnKey);
    return containsColumn(columnKey)

    ImmutableTableCollectorState<R, C, V> combine(
        ImmutableTableCollectorState<R, C, V> other, BinaryOperator<V> merger) {
      for (MutableCell<R, C, V> cell : other.insertionOrder) {
        put(cell.getRowKey(), cell.getColumnKey(), cell.getValue(), merger);
      }
      return this;
    }

    ImmutableTable<R, C, V> toTable() {
      return ImmutableTable.copyOf(insertionOrder);
    }
  }

      return Maps.transformValues(fromTable.column(columnKey), function);
    }

    Cell<R, C, V2> applyToValue(Cell<R, C, V1> cell) {
      return immutableCell(cell.getRowKey(), cell.getColumnKey(), function.apply(cell.getValue()));
    }

    @Override
    Iterator<Cell<R, C, V2>> cellIterator() {
      return Iterators.transform(fromTable.cellSet().iterator(), this::applyToValue);
    }

  public LongAdder() {}

  /**
   * Adds the given value.
   *
   * @param x the value to add
   */
  @Override
  public void add(long x) {
    Cell[] as;
    long b, v;
    int[] hc;
    Cell a;
    int n;
    if ((as = cells) != null || !casBase(b = base, b + x)) {
      boolean uncontended = true;
      if ((hc = threadHashCode.get()) == null
          || as == null

   *
   * @since 7.0
   */
  interface Cell<
      R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object> {
    /** Returns the row key of this cell. */
    @ParametricNullness
    R getRowKey();

    /** Returns the column key of this cell. */
    @ParametricNullness
    C getColumnKey();

    /** Returns the value of this cell. */
    @ParametricNullness
    V getValue();

permissions: {}

jobs:
  check_pull_metadata:
    permissions:
      issues: write
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      # Check that PRs have proper metadata: labels and milestone
      # https://github.com/gradle/issue-management-action/blob/main/src/pull-metadata.ts

  TF_DeleteStatus(status);
  return counter;
}

void IncrementCounter0(TFE_MonitoringCounter0* counter, int64_t delta) {
  auto* cell = TFE_MonitoringGetCellCounter0(counter);
  TFE_MonitoringCounterCellIncrementBy(cell, delta);
}

TFE_MonitoringCounter1* CreateCounter1(const char* counter_name,
                                       const char* label) {
  TF_Status* status = TF_NewStatus();

  public LongAdder() {}

  /**
   * Adds the given value.
   *
   * @param x the value to add
   */
  @Override
  public void add(long x) {
    Cell[] as;
    long b, v;
    int[] hc;
    Cell a;
    int n;
    if ((as = cells) != null || !casBase(b = base, b + x)) {
      boolean uncontended = true;
      if ((hc = threadHashCode.get()) == null
          || as == null