/**
 * SMB2 SRV_COPYCHUNK data structure. This structure represents a single chunk specification
 * for server-side copy operations.
 *
 * @author mbechler
 *
 */
public class SrvCopychunk implements Encodable {

    private final long sourceOffset;
    private final long targetOffset;
    private final int length;

    /**
     * Constructs a server copy chunk descriptor
     * @param soff the source file offset

      for (int remaining = len; remaining >= 3; remaining -= 3) {
        int chunk = (bytes[i++] & 0xFF) << 16 | (bytes[i++] & 0xFF) << 8 | (bytes[i++] & 0xFF);
        target.append(alphabet.encode(chunk >>> 18));
        target.append(alphabet.encode((chunk >>> 12) & 0x3F));
        target.append(alphabet.encode((chunk >>> 6) & 0x3F));
        target.append(alphabet.encode(chunk & 0x3F));
      }
      if (i < off + len) {

	}
	f.(*fileWriter).crc32 = fakeHash32{}
	chunk := make([]byte, chunkSize)
	for i := range chunk {
		chunk[i] = '.'
	}
	for i := 0; i < chunks; i++ {
		_, err := f.Write(chunk)
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	if frag := int(size % chunkSize); frag > 0 {
		_, err := f.Write(chunk[:frag])
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	end := []byte("END\n")

    this.bufferSize = bufferSize;
    this.chunkSize = chunkSize;
  }

  /** Processes the available bytes of the buffer (at most {@code chunk} bytes). */
  protected abstract void process(ByteBuffer bb);

  /**
   * This is invoked for the last bytes of the input, which are not enough to fill a whole chunk.
   * The passed {@code ByteBuffer} is guaranteed to be non-empty.
   *

	"io"
	"sync/atomic"
)

const (
	chunk    = 4095 // ~4k
	maxUint  = ^uint(0)
	maxInt   = int64(maxUint >> 1)
	nullByte = byte(0)
)

type scanner struct {
	pos       int64 // position in reader
	ipos      int64 // internal buffer position
	ifill     int64 // internal buffer fill
	end       int64
	buf       [chunk + 1]byte // internal buffer (with a lookback size of 1)
	nbuf      [chunk]byte     // next internal buffer

s3.getObject({Bucket: 'your-bucket', Key: 'path/to/file.zip/data.csv'}).
    on('build', function(req) { req.httpRequest.headers['X-Minio-Extract'] = 'true'; }).
    on('httpData', function(chunk) { file.write(chunk); }).
    on('httpDone', function() { file.end(); }).

    /**
     * Function code to transceive data on a named pipe
     */
    public static final int FSCTL_PIPE_TRANSCEIVE = 0x0011C017;
    /**
     * Function code for server-side copy chunk operation
     */
    public static final int FSCTL_SRV_COPYCHUNK = 0x001440F2;
    /**
     * Function code to enumerate volume shadow copy snapshots
     */

   * @param last when true, there is no response data.
   */
  fun onHeaders(
    streamId: Int,
    responseHeaders: List<Header>,
    last: Boolean,
  ): Boolean

  /**
   * A chunk of response data corresponding to a pushed request.  This data must either be read or
   * skipped.
   *
   * @param streamId server-initiated stream ID: an even number.

    public SrvCopyChunkCopyResponse() {
    }

    private int chunksWritten;
    private int chunkBytesWritten;
    private int totalBytesWritten;

    /**
     * Gets the number of bytes written in the last chunk
     * @return the chunkBytesWritten
     */
    public int getChunkBytesWritten() {
        return this.chunkBytesWritten;
    }

    /**
     * Gets the number of chunks successfully written

        // Write 11MB of data
        try (FileOutputStream fos = new FileOutputStream(largeFile)) {
            final byte[] chunk = new byte[1024 * 1024]; // 1MB
            for (int i = 0; i < 11; i++) { // Write 11MB
                fos.write(chunk);
            }
        }

        try {
            FileUtil.readBytes(largeFile);
            fail("Expected IORuntimeException for large file");