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 parent.containsAll(c);
        }

  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public void clear() {
    Iterators.clear(cellSet().iterator());
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V remove(@Nullable Object rowKey, @Nullable Object columnKey) {
    Map<C, V> row = safeGet(rowMap(), rowKey);
    return (row == null) ? null : Maps.safeRemove(row, columnKey);
  }

  @CanIgnoreReturnValue
  @Override

  // TODO(b/192446998): Remove this override after tools understand nullness better.
  public @Nullable V put(K key, @ParametricNullness V value) {
    return super.put(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  @SuppressWarnings("RedundantOverride") // b/192446478: RedundantOverride ignores some annotations.
  // TODO(b/192446998): Remove this override after tools understand nullness better.

            final TimeoutTask task = e.getElement();
            if (task.isCanceled()) {
                e.remove();
            } else if (!task.isStopped() && task.isExpired()) {
                expiredTask.add(task);
                if (!task.isPermanent()) {
                    e.remove();
                }
            }
        }
        return expiredTask;
    }

    /**

     *
     * @param key the key under which to store the session data, must not be {@code null}
     * @param value the data to associate with the key, may be {@code null} to remove the mapping
     */
    <T> void set(@Nonnull Key<T> key, @Nullable T value);

    /**
     * Associates the specified session data with the given key if the key is currently mapped to the given value. This

        if (listener != null) {
            listeners.add(listener);
        }
    }

    /**
     * Remove a listener
     *
     * @param listener the listener to remove
     */
    public void removeListener(CircuitBreakerListener listener) {
        listeners.remove(listener);
    }

    /**
     * Get circuit breaker metrics
     *
     * @return metrics snapshot
     */

   */

  // Currently, we don't include stream() and spliterator() for our classes in the Android flavor.

  @Override
  public boolean remove(@Nullable Object o) {
    assertTrue(Thread.holdsLock(mutex));
    return super.remove(o);
  }

  @Override
  public boolean removeAll(Collection<?> c) {
    assertTrue(Thread.holdsLock(mutex));
    return super.removeAll(c);
  }

      assertTrue(Thread.holdsLock(mutex));
      delegate.putAll(table);
    }

    @Override
    public @Nullable V remove(Object rowKey, Object columnKey) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove(rowKey, columnKey);
    }

    @Override
    public Map<C, V> row(R rowKey) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.row(rowKey);

if [[ "$TFCI_ARTIFACT_STAGING_GCS_ENABLE" == 1 ]]; then
  # Note: -n disables overwriting previously created files.
  # TODO(b/389744576): Remove when gsutil is made to work properly on MSYS2.
  if [[ $(uname -s) != MSYS_NT* ]]; then
    gsutil cp "$TFCI_OUTPUT_DIR"/*.tar.gz "$TFCI_ARTIFACT_STAGING_GCS_URI"
  else

 * Table} interface.
 *
 * <p>The views returned by {@link #column}, {@link #columnKeySet()}, and {@link #columnMap()} have
 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in