}

    /**
     * Adds one or more warnings to the given test
     *
     * @param testName the test name to add the warning
     * @param warnings the warning(s) to add
     */
    public void addWarning(String testName, String... warnings) {
        transformations.add(new InjectWarnings(Arrays.asList(warnings), testName));
    }

    /**
     * Adds one or more regex warnings to the given test

	}
	tw.curr = &regFileWriter{tw.w, size}
	tw.pad = blockPadding(size)
	return nil
}

// AddFS adds the files from fs.FS to the archive.
// It walks the directory tree starting at the root of the filesystem
// adding each file to the tar archive while maintaining the directory structure.
func (tw *Writer) AddFS(fsys fs.FS) error {
	return fs.WalkDir(fsys, ".", func(name string, d fs.DirEntry, err error) error {
		if err != nil {

   * #add(Range) add} any range not {@linkplain Range#encloses(Range) enclosed} by {@code view}.
   */
  RangeSet<C> subRangeSet(Range<C> view);

  // Modification

  /**
   * Adds the specified range to this {@code RangeSet} (optional operation). That is, for equal
   * range sets a and b, the result of {@code a.add(range)} is that {@code a} will be the minimal

	for _, sub := range ps.subs {
		if sub.types.Contains(Mask(item.Mask())) && (sub.filter == nil || sub.filter(item)) {
			select {
			case sub.ch <- item:
			default:
			}
		}
	}
}

// Subscribe - Adds a subscriber to pubsub system
func (ps *PubSub[T, M]) Subscribe(mask M, subCh chan T, doneCh <-chan struct{}, filter func(entry T) bool) error {
	totalSubs := atomic.AddInt32(&ps.numSubscribers, 1)

        header.previous.remove();
        return last;
    }

    /**
     * Adds an element at the beginning.
     *
     * @param element the object to be added
     */
    public void addFirst(final E element) {
        header.next.addBefore(element);
    }

    /**
     * Adds an element at the end.
     *
     * @param element the object to be added
     */

        final SmbResourceLocator locator = parent.getLocator();
        if (locator.getURL().getHost().isEmpty()) {
            // smb:// -> enumerate servers through browsing
            Address addr;
            try {
                addr = locator.getAddress();
            } catch (final CIFSException e) {
                if (e.getCause() instanceof UnknownHostException) {
                    log.debug("Failed to find master browser", e);

					if elem.Kind() == reflect.Map {
						processMap(elem)
						continue
					}
					appendToFieldValues(elem.Addr())
				}
			case reflect.Struct:
				if !rv.CanAddr() {
					association.Error = ErrInvalidValue
					return
				}
				appendToFieldValues(rv.Addr())
			}

			if association.Error == nil {

      // modify this builder, so we make a copy instead.
      this.mutableGraph = graphBuilder.copy().incidentEdgeOrder(ElementOrder.<N>stable()).build();
    }

    /**
     * Adds {@code node} if it is not already present.
     *
     * <p><b>Nodes must be unique</b>, just as {@code Map} keys must be. They must also be non-null.
     *
     * @return this {@code Builder} object
     */

 * limitations under the License.
 */
package okhttp3.brotli

import okhttp3.CompressionInterceptor
import okhttp3.Gzip

/**
 * Transparent Brotli response support.
 *
 * Adds Accept-Encoding: br to request and checks (and strips) for Content-Encoding: br in
 * responses.  n.b. this replaces the transparent gzip compression in BridgeInterceptor.
 */

    return delegate;
  }

  /**
   * Adds the given element to this queue. If the queue is currently full, the element at the head
   * of the queue is evicted to make room.
   *
   * @return {@code true} always
   */
  @Override
  @CanIgnoreReturnValue
  public boolean offer(E e) {
    return add(e);
  }

  /**