@@ -21,16 +21,10 @@ // at the expense of time. func (ctx *context) update(val byte) { ctx.hash = (ctx.hash << 4) ^ uint16(val) } -type compressor func([]byte) error - -func (w compressor) Write(data []byte) (int, error) { - return len(data), w(data) -} - // Returns an io.Writer implementation that wraps the provided io.Writer // and compresses data according to the predictor algorithm // // It can buffer data as the predictor mandates 8-byte blocks with a header. // A call with no data will force a flush. @@ -37,56 +31,58 @@ func Compressor(writer io.Writer) io.Writer { var ctx context ctx.input = make([]byte, 0, 8) // Forward declaration as it is required for recursion - var write compressor + var write iou.WriterFunc - write = func(data []byte) error { + write = func(data []byte) (int, error) { var ( blockSize int = 8 bufferLength int = len(ctx.input) + datalength int = len(data) ) // Force a flush if we are called with no data to write - if len(data) == 0 { + if datalength == 0 { // Nothing to flush if the buffer is empty though if len(ctx.input) == 0 { - return nil + return 0, nil } // We can't have more than 7 bytes in the buffer so this is safe - data, blockSize, bufferLength = ctx.input, len(ctx.input), 0 + data, datalength = ctx.input, len(ctx.input) + blockSize, bufferLength = datalength, 0 } // Check if there are pending bytes in the buffer - if len(data) < blockSize || bufferLength > 0 { + if datalength < blockSize || bufferLength > 0 { // If the current buffer + new data can fit into a block - if (len(data) + bufferLength) <= blockSize { + if (datalength + bufferLength) <= blockSize { ctx.input = append(ctx.input, data...) // Flush the block if the buffer fills it if len(ctx.input) == blockSize { return write(nil) } // ... otherwise just return - return nil + return datalength, nil } // The current buffer + new data overflow the block size // Complete the block, flush it ... ctx.input = append(ctx.input, data[:blockSize-bufferLength]...) - if err := write(nil); err != nil { - return err + if c, err := write(nil); err != nil { + return c, err } // ... and stage the rest of the data in the buffer ctx.input = append(ctx.input, data[blockSize-bufferLength:]...) - return nil + return datalength, nil } var buf []byte = make([]byte, 1, blockSize+1) - for block := 0; block < len(data)/blockSize; block++ { + for block := 0; block < datalength/blockSize; block++ { for i := 0; i < blockSize; i++ { var current byte = data[(block*blockSize)+i] if ctx.table[ctx.hash] == current { // Guess was right - don't output buf[0] |= 1 << uint(i) @@ -96,26 +92,26 @@ buf = append(buf, current) } ctx.update(current) } - if _, err := writer.Write(buf); err != nil { - return err + if c, err := writer.Write(buf); err != nil { + return (block * blockSize) + c, err } // Reset the flags and buffer for the next iteration buf, buf[0] = buf[:1], 0 } - if remaining := len(data) % blockSize; remaining > 0 { + if remaining := datalength % blockSize; remaining > 0 { ctx.input = ctx.input[:remaining] - copy(ctx.input, data[len(data)-remaining:]) + copy(ctx.input, data[datalength-remaining:]) } else { ctx.input = ctx.input[:0] } - return nil + return datalength, nil } return write }