Function compress

rpc_util.go:834–869

compress returns the input bytes compressed by compressor or cp. If both compressors are nil, or if the message has zero length, returns nil, indicating no compression was done. TODO(dfawley): eliminate cp parameter by wrapping Compressor in an encoding.Compressor.

(in mem.BufferSlice, cp Compressor, compressor encoding.Compressor, pool mem.BufferPool)

//
// TODO(dfawley): eliminate cp parameter by wrapping Compressor in an encoding.Compressor.
func compress(in mem.BufferSlice, cp Compressor, compressor encoding.Compressor, pool mem.BufferPool) (mem.BufferSlice, payloadFormat, error) {
	if (compressor == nil && cp == nil) || in.Len() == 0 {
		return nil, compressionNone, nil
	}
	var out mem.BufferSlice
	w := mem.NewWriter(&out, pool)
	wrapErr := func(err error) error {
		out.Free()
		return status.Errorf(codes.Internal, "grpc: error while compressing: %v", err.Error())
	}
	if compressor != nil {
		z, err := compressor.Compress(w)
		if err != nil {
			return nil, compressionNone, wrapErr(err)
		}
		for _, b := range in {
			if _, err := z.Write(b.ReadOnlyData()); err != nil {
				return nil, compressionNone, wrapErr(err)
			}
		}
		if err := z.Close(); err != nil {
			return nil, compressionNone, wrapErr(err)
		}
	} else {
		// This is obviously really inefficient since it fully materializes the data, but
		// there is no way around this with the old Compressor API. At least it attempts
		// to return the buffer to the provider, in the hopes it can be reused (maybe
		// even by a subsequent call to this very function).
		buf := in.MaterializeToBuffer(pool)
		defer buf.Free()
		if err := cp.Do(w, buf.ReadOnlyData()); err != nil {
			return nil, compressionNone, wrapErr(err)
		}
	}
	return out, compressionMade, nil
}

const (
	payloadLen = 1