* OutputStream} (when {@code copyTo(OutputStream)} is called on the resulting {@code
   * ByteSource}). This could allow a malicious {@code OutputStream} implementation to modify the
   * contents of the array, but provides better performance in the normal case.
   *
   * @since 15.0 (since 14.0 as {@code ByteStreams.asByteSource(byte[])}).
   */
  public static ByteSource wrap(byte[] b) {
    return new ByteArrayByteSource(b);
  }

    protected boolean port139FailoverEnabled = false;
    /** Whether to use NT SMB operations */
    protected boolean useNTSmbs = true;
    /** Whether to use large read/write operations for better performance */
    protected boolean useLargeReadWrite = true;
    /** LAN Manager compatibility level for authentication */
    protected int lanmanCompatibility = 3;

### Чи краща рівночасність за паралелізм? { #is-concurrency-better-than-parallelism }

Ні! Це не мораль історії.

And after searching for a long time for a similar framework and testing many different alternatives, APIStar was the best option available.

Then APIStar stopped to exist as a server and Starlette was created, and was a new better foundation for such a system. That was the final inspiration to build **FastAPI**.

    // do n swaps, minus a delta (0 or 2 for Reversal, gcd(d, n) for Successive), so that's about
    // twice as many reads and writes. But benchmarking shows that they usually perform better than
    // Dolphin. Reversal is about as good as Successive on average, and it is much simpler,
    // especially since we already have a `reverse` method.
    checkNotNull(array);

   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note
   * that we choose not to make this volatile, so we do less of a "best effort" to track such
   * errors, for better performance.
   *
   * <p>For a new instance, where the arrays above have not yet been allocated, the value of {@code
   * metadata} is the size that the arrays should be allocated with. Once the arrays have been

   *
   * <p>If {@code expectedSize} is exactly the number of distinct elements added to the builder
   * before {@link Builder#build} is called, the builder is likely to perform better than an unsized
   * {@link #builder()} would have.
   *
   * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to,

        queue[index] = parentElement;
        queue[parentIndex] = x;
        return parentIndex;
      }
      queue[index] = x;
      return index;
    }

    // About the term "aunt node": it's better to leave gender out of it, but for this the English
    // language has nothing for us. Except for the whimsical neologism "pibling" (!) which we
    // obviously could not expect to increase anyone's understanding of the code.

   *
   * <p>If {@code keys} is a {@link Set}, a live view can be obtained instead of a copy using {@link
   * Maps#asMap(Set, Function)}.
   *
   * <p><b>Note:</b> on Java 8+, it is usually better to use streams. For example:
   *
   * {@snippet :
   * import static com.google.common.collect.ImmutableMap.toImmutableMap;
   * ...
   * ImmutableMap<Color, String> colorNames =

   *
   * <p>If {@code keys} is a {@link Set}, a live view can be obtained instead of a copy using {@link
   * Maps#asMap(Set, Function)}.
   *
   * <p><b>Note:</b> on Java 8+, it is usually better to use streams. For example:
   *
   * {@snippet :
   * import static com.google.common.collect.ImmutableMap.toImmutableMap;
   * ...
   * ImmutableMap<Color, String> colorNames =