// accepted and all subsequent writes, and [Writer.Flush], will return the error.
// After all data has been written, the client should call the
// [Writer.Flush] method to guarantee all data has been forwarded to
// the underlying [io.Writer].
type Writer struct {
	err error
	buf []byte
	n   int
	wr  io.Writer
}

        }
    }

    /**
     * Writes the contents of the byte buffer to the file channel.
     *
     * @param channel
     *            The file channel. Must not be {@literal null}.
     * @param buffer
     *            The byte buffer. Must not be {@literal null}.
     * @return The number of bytes written.
     */
    public static int write(final FileChannel channel, final ByteBuffer buffer) {

        assertEquals(off, getFieldValue(write, "off"), "Off should be updated");
        assertEquals(len, getFieldValue(write, "count"), "Count should be updated");
        assertEquals(SMB_COM_WRITE, write.command, "Command should be SMB_COM_WRITE");
    }

    /**
     * Test writeParameterWordsWireFormat writes correct bytes
     */
    @Test
    public void testWriteParameterWordsWireFormat() {

    }

    /**
     * Calculate average write latency in microseconds
     *
     * @return average write latency
     */
    public double getAverageWriteLatencyMicros() {
        long writes = rdmaWrites.get();
        if (writes == 0) {
            return 0.0;
        }
        return totalWriteTime.get() / (double) writes / 1000.0; // Convert to microseconds
    }

    /**

        tmp = null;
    }

    /**
     * Writes the specified byte to this file output stream.
     *
     * @throws IOException if a network error occurs
     */

    @Override
    public void write(final int b) throws IOException {
        tmp[0] = (byte) b;
        write(tmp, 0, 1);
    }

    /**
     * Writes b.length bytes from the specified byte array to this

 * under the License.
 */
package org.apache.maven.api.services.xml;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.toolchain.PersistedToolchains;

/**
 * Reads and writes a {@link PersistedToolchains} object to/from XML.
 *
 * @since 4.0.0
 */
@Experimental

            if (item != null && item.isUpdated()) {
                try {
                    writer.write(item.toLineString());
                    writer.write(Constants.LINE_SEPARATOR);
                    return item;
                } catch (final IOException e) {
                    throw new DictionaryException("Failed to write: " + item, e);
                }
            }
            return null;
        }

        // Decode to new instance (decode reads 36 bytes, encode writes 40)
        FileBasicInfo decoded = new FileBasicInfo();
        int decodedBytes = decoded.decode(buffer, 0, 36);

        // Verify encoding/decoding
        assertEquals(40, encodedBytes); // encode writes 40 bytes (includes padding)
        assertEquals(36, decodedBytes); // decode reads 36 bytes (no padding)

![quota](https://raw.githubusercontent.com/minio/minio/master/docs/bucket/quota/bucketquota.png)

Buckets can be configured to have `Hard` quota - it disallows writes to the bucket after configured quota limit is reached.

## Prerequisites

   * use this feature.
   *
   * ### Duplex APIs
   *
   * With regular request bodies it is not legal to write bytes to the sink passed to
   * [RequestBody.writeTo] after that method returns. For duplex requests bodies that condition is
   * lifted. Such writes occur on an application-provided thread and may occur concurrently with
   * reads of the [ResponseBody]. For duplex request bodies, [writeTo] should return