@@ -25,69 +25,70 @@ // that it is never called with less bytes than the specified amount. // // Calls with fewer bytes are buffered while a call with a nil slice // causes the buffer to be flushed to the underlying writer. func SizedWriter(writer io.Writer, size int) io.Writer { - var buffer []byte = make([]byte, 0, size) - var write WriterFunc - - write = func(input []byte) (int, error) { - var ( - count int - err error - ) - - // Flush the buffer when called with no bytes to write - if input == nil { - // Call the writer with whatever we have in store.. - count, err = writer.Write(buffer) - - // Advance the buffer - buffer = buffer[:copy(buffer, buffer[count:])] - - return 0, err - } - - // Delegate to the writer if the size is right - if len(buffer) == 0 && len(input) >= size { - reduced := (len(input) / size) * size - count, err = writer.Write(input[:reduced]) - if count < reduced || err != nil { - return count, err - } - - // Stage any remaining data in the buffer - buffer = append(buffer, input[count:]...) - return len(input), nil - } - - // Append data to the buffer - count = copy(buffer[len(buffer):size], input) - buffer = buffer[:len(buffer)+count] - - // Return if we don't have enough bytes to write - if len(buffer) < size { - return len(input), nil - } - - // Flush the buffer as it is filled - _, err = write(nil) - if err != nil { - return count, err - } - - // Handle the rest of the input - return write(input[count:]) - } - - return write -} - -type sizedReader struct { - reader io.Reader - buffer []byte - from, to, size int + var sw sizedWriter + sw.writer = writer + sw.buffer = make([]byte, 0, size) + sw.size = size + return &sw +} + +type sizedWriter struct { + writer io.Writer + buffer []byte + size int +} + +func (sw *sizedWriter) Write(input []byte) (int, error) { + var ( + count int + err error + ) + + // Flush the buffer when called with no bytes to write + if input == nil { + // Call the writer with whatever we have in store.. + count, err = sw.writer.Write(sw.buffer) + + // Advance the buffer + sw.buffer = sw.buffer[:copy(sw.buffer, sw.buffer[count:])] + + return 0, err + } + + // Delegate to the writer if the size is right + if len(sw.buffer) == 0 && len(input) >= sw.size { + reduced := (len(input) / sw.size) * sw.size + count, err = sw.writer.Write(input[:reduced]) + if count < reduced || err != nil { + return count, err + } + + // Stage any remaining data in the buffer + sw.buffer = append(sw.buffer, input[count:]...) + return len(input), nil + } + + // Append data to the buffer + count = copy(sw.buffer[len(sw.buffer):sw.size], input) + sw.buffer = sw.buffer[:len(sw.buffer)+count] + + // Return if we don't have enough bytes to write + if len(sw.buffer) < sw.size { + return len(input), nil + } + + // Flush the buffer as it is filled + _, err = sw.Write(nil) + if err != nil { + return count, err + } + + // Handle the rest of the input + return sw.Write(input[count:]) } // Returns a reader that delegates calls to Read(...) while ensuring // that the output buffer is never smaller than the required size // and is downsized to a multiple of the required size if larger. @@ -96,10 +97,16 @@ sr.reader = reader sr.buffer = make([]byte, size) sr.size, sr.from, sr.to = size, 0, 0 return &sr } + +type sizedReader struct { + reader io.Reader + buffer []byte + from, to, size int +} func (sr *sizedReader) Read(output []byte) (int, error) { var ( count int err error