nameLen, err := direntNamlen(dirent)
	if err != nil {
		return consumed, nil, typ, err
	}

	return consumed, nameBuf[:nameLen], typ, nil
}

// readDirFn applies the fn() function on each entries at dirPath, doesn't recurse into
// the directory itself, if the dirPath doesn't exist this function doesn't return
// an error.
func readDirFn(dirPath string, fn func(name string, typ os.FileMode) error) error {

            Each source is specified by a {@code directory} element, which is relative to the POM.
            The kind of sources (source files to compile or resources to copy) and their usage (for the main code
            or for the tests) is specified by the {@code scope} element together with each source directory.
          </description>
          <association>

// Adjust fixed content padding\n      $(fixedContent).each((index, element) => {\n        const actualPadding = element.style.paddingRight\n        const calculatedPadding = $(element).css('padding-right')\n        $(element)\n          .data('padding-right', actualPadding)\n          .css('padding-right', `${parseFloat(calculatedPadding) + this._scrollbarWidth}px`)\n      })\n\n      // Adjust sticky content margin\n      $(stickyContent).each((index, element) => {\n        const actualMargin = ...

   * index.
   *
   * <p>Its size must be a power of two.
   */
  private transient int[] table;

  /**
   * Contains the logical entries, in the range of [0, size()). The high 32 bits of each long is the
   * smeared hash of the element, whereas the low 32 bits is the "next" pointer (pointing to the
   * next entry in the bucket chain). The pointers in [size(), entries.length) are all "null"
   * (UNSET).
   */

                    WitnessAsyncNotifyMessage.WitnessNotificationResponse response = rpcClient.getAsyncNotifications(contextHandle);

                    if (response != null) {
                        // Process each notification message
                        for (WitnessAsyncNotifyMessage.WitnessNotificationMessage message : response.getMessages()) {
                            processAsyncNotificationMessage(registration, message);

    Function<? super Integer, Y> g = SerializableTester.reserializeAndAssert(f);
    for (int i = 1; i < 5; i++) {
      // convoluted way to check that the same result happens from each
      Y expected = null;
      try {
        expected = f.apply(i);
      } catch (IllegalArgumentException e) {
        try {
          g.apply(i);
          fail();

    a malformed URL.)

 *  **We've improved connect failure recovery.** We now differentiate between
    setup, connecting, and connected and implement appropriate recovery rules
    for each. This changes `Address` to no longer use `ConnectionSpec`. (This is
    an incompatible API change).

 *  **`FormEncodingBuilder` now uses `%20` instead of `+` for encoded spaces.**

import org.dbflute.optional.OptionalEntity;

/**
 * Manages a dictionary file for stemmer overrides.
 * This class handles reading, parsing, and updating files that contain
 * stemmer override rules, where each rule maps an input word to an
 * output stem. The file format is expected to be `input => output`.
 *
 * The class provides methods for retrieving, adding, updating, and

      backingMap.clear();
    }
  }

  /**
   * {@inheritDoc}
   *
   * <p>The set's iterator traverses the mappings for the first row, the mappings for the second
   * row, and so on.
   *
   * <p>Each cell is an immutable snapshot of a row key / column key / value mapping, taken at the
   * time the cell is returned by a method call to the set or its iterator.
   */
  @Override
  public Set<Cell<R, C, V>> cellSet() {

    parameter to be non-null was an unintended signature change in OkHttp 4.0.

 *  New: `EventListener.retryDecision()` is called each time a request fails with an `IOException`.
    It notifies your listener if OkHttp will retry.

 *  New: `EventListener.followUpDecision()` is called each time a response is received. It notifies
    your listener if OkHttp has decided to make a follow-up request. Some common follow-ups are