### Asynchronous Get ([.kt][AsynchronousGetKotlin], [.java][AsynchronousGetJava])

Download a file on a worker thread, and get called back when the response is readable. The callback is made after the response headers are ready. Reading the response body may still block. OkHttp doesn't currently offer asynchronous APIs to receive a response body in parts.

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client = OkHttpClient()

      if (byte1 < (byte) 0xE0) {
        // Two-byte form.
        if (index == end) {
          return false;
        }
        // Simultaneously check for illegal trailing-byte in leading position
        // and overlong 2-byte form.
        if (byte1 < (byte) 0xC2 || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      } else if (byte1 < (byte) 0xF0) {
        // Three-byte form.

Here's a little bit of that history.

## Alternatives { #alternatives }

I have been creating APIs with complex requirements for several years (Machine Learning, distributed systems, asynchronous jobs, NoSQL databases, etc), leading several teams of developers.

As part of that, I needed to investigate, test and use many alternatives.

The history of **FastAPI** is in great part the history of its predecessors.

    // contain non-decimal characters.
    int length = end - start;
    if (length <= 0 || length > 3) {
      throw new NumberFormatException();
    }
    // Disallow leading zeroes, because no clear standard exists on
    // whether these should be interpreted as decimal or octal.
    if (length > 1 && ipString.charAt(start) == '0') {
      throw new NumberFormatException();
    }

       * use the `endpoint` field, compareTo() and endpoint(). Additionally, the main implementation
       * of Cut.compareTo checks for belowAll before reading accessing `endpoint` on another Cut
       * instance.
       */
      super("");
    }

    @Override
    Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");

 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *
 * These examples will not work if you're consuming the response body on another thread. In such
 * cases the consuming thread must call [close] when it has finished reading the response
 * body.
 *
 * ### The response body can be consumed only once.
 *
 * This class may be used to stream very large responses. For example, it is possible to use this

        void testDecodeWithBufferOverflow() {
            assertThrows(SMBProtocolDecodingException.class, () -> testResponse.decode(testBuffer, 250, 10),
                    "Should throw exception when reading beyond buffer bounds");
        }

        @Test
        @DisplayName("Should handle zero-length decode")
        void testDecodeWithZeroLength() throws SMBProtocolDecodingException {

* **Intuitive**: Great editor support. <abbr title="also known as auto-complete, autocompletion, IntelliSense">Completion</abbr> everywhere. Less time debugging.
* **Easy**: Designed to be easy to use and learn. Less time reading docs.
* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
* **Robust**: Get production-ready code. With automatic interactive documentation.

* Do not change the paths in links to images, code files, Markdown documents.

* However, when a Markdown document is translated, the `#hash-parts` in links to its headings may change. Update these links if possible.
    * Search for such links in the translated document using the regex `#[^# ]`.

    private String server;

    private boolean resolveDfs;

    /**
     * Constructs an SMB2 create request
     * @param config the client configuration
     * @param name uncPath to open, strips a leading \
     */
    public Smb2CreateRequest(final Configuration config, final String name) {
        super(config, SMB2_CREATE);
        setPath(name);
    }

    @Override