* limitations under the License.
 */

package okhttp3.internal.connection

import java.net.Inet6Address
import java.net.InetAddress
import okhttp3.internal.interleave

/**
 * Implementation of HappyEyeballs Sorting Addresses.
 *
 * The current implementation does not address any of:
 *  - Async DNS split by IP class
 *  - Stateful handling of connectivity results

) {
  if (offset or count < 0L || offset > arrayLength || arrayLength - offset < count) {
    throw ArrayIndexOutOfBoundsException("length=$arrayLength, offset=$offset, count=$offset")
  }
}

internal fun <T> interleave(
  a: Iterable<T>,
  b: Iterable<T>,
): List<T> {
  val ia = a.iterator()
  val ib = b.iterator()

  return buildList {
    while (ia.hasNext() || ib.hasNext()) {
      if (ia.hasNext()) {

 *
 * This nesting is typical but not strict. For example, when calls use "Expect: continue" the
 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present
 * for a call. In future releases of OkHttp these events may also occur concurrently to permit

      if (result == CancellationException.class) {
        assertTrue(future.isCancelled());
        assertTrue(cancellationSuccess.get());
        // cancellation can interleave in 3 ways
        // 1. prior to setFuture
        // 2. after setFuture before set() on the future assigned
        // 3. after setFuture and set() are called but before the listener completes.

      if (result == CancellationException.class) {
        assertTrue(future.isCancelled());
        assertTrue(cancellationSuccess.get());
        // cancellation can interleave in 3 ways
        // 1. prior to setFuture
        // 2. after setFuture before set() on the future assigned
        // 3. after setFuture and set() are called but before the listener completes.

    *   Add delegate support for `QUANTIZED_16BIT_LSTM`.
    *   Converts hardswish subgraphs into atomic ops.
*   Add support for defaulting the value of `cycle_length` argument of
    `tf.data.Dataset.interleave` to the number of schedulable CPU cores.
*   `parallel_for`: Add converter for `MatrixDiag`.
*   Add `narrow_range` attribute to `QuantizeAndDequantizeV2` and V3.
*   Added new op: `tf.strings.unsorted_segment_join`.

   *
   * ### Duplex Transmission
   *
   * With regular HTTP calls the request always completes sending before the response may begin
   * receiving. With duplex the request and response may be interleaved! That is, request body bytes
   * may be sent after response headers or body bytes have been received.
   *
   * Though any call may be initiated as a duplex call, only web servers that are specially

    <glob pattern="*.wmx"/>
  </mime-type>
  <mime-type type="video/x-ms-wvx">
    <glob pattern="*.wvx"/>
  </mime-type>

  <mime-type type="video/x-msvideo">
    <_comment>Audio Video Interleave File</_comment>
    <alias type="video/avi"/>
    <alias type="video/msvideo"/>
    <magic priority="50">
      <match value="RIFF....AVI " type="string" offset="0"
             mask="0xFFFFFFFF00000000FFFFFFFF"/>

   *  * If it is a message frame this will result in a single call to [FrameCallback.onReadMessage].
   *    If the message spans multiple frames, each interleaved control frame will result in a
   *    corresponding call to [FrameCallback].
   */
  @Throws(IOException::class)
  fun processNextFrame() {
    readHeader()
    if (isControlFrame) {
      readControlFrame()

    // a multithreaded environment for a couple of reasons:
    //
    // 1. Subscribers to events posted on different threads can be interleaved with each other
    //    freely. (A event on one thread, B event on another could yield any of
    //    [a1, a2, a3, b1, b2], [a1, b2, a2, a3, b2], [a1, b2, b3, a2, a3], etc.)