[VOL-5486] Upgrade library versions
Change-Id: I8b4e88699e03f44ee13e467867f45ae3f0a63c4b
Signed-off-by: Abhay Kumar <abhay.kumar@radisys.com>
diff --git a/vendor/github.com/pierrec/lz4/v4/options.go b/vendor/github.com/pierrec/lz4/v4/options.go
new file mode 100644
index 0000000..57a44e7
--- /dev/null
+++ b/vendor/github.com/pierrec/lz4/v4/options.go
@@ -0,0 +1,242 @@
+package lz4
+
+import (
+ "fmt"
+ "reflect"
+ "runtime"
+
+ "github.com/pierrec/lz4/v4/internal/lz4block"
+ "github.com/pierrec/lz4/v4/internal/lz4errors"
+)
+
+//go:generate go run golang.org/x/tools/cmd/stringer -type=BlockSize,CompressionLevel -output options_gen.go
+
+type (
+ applier interface {
+ Apply(...Option) error
+ private()
+ }
+ // Option defines the parameters to setup an LZ4 Writer or Reader.
+ Option func(applier) error
+)
+
+// String returns a string representation of the option with its parameter(s).
+func (o Option) String() string {
+ return o(nil).Error()
+}
+
+// Default options.
+var (
+ DefaultBlockSizeOption = BlockSizeOption(Block4Mb)
+ DefaultChecksumOption = ChecksumOption(true)
+ DefaultConcurrency = ConcurrencyOption(1)
+ defaultOnBlockDone = OnBlockDoneOption(nil)
+)
+
+const (
+ Block64Kb BlockSize = 1 << (16 + iota*2)
+ Block256Kb
+ Block1Mb
+ Block4Mb
+)
+
+// BlockSizeIndex defines the size of the blocks to be compressed.
+type BlockSize uint32
+
+// BlockSizeOption defines the maximum size of compressed blocks (default=Block4Mb).
+func BlockSizeOption(size BlockSize) Option {
+ return func(a applier) error {
+ switch w := a.(type) {
+ case nil:
+ s := fmt.Sprintf("BlockSizeOption(%s)", size)
+ return lz4errors.Error(s)
+ case *Writer:
+ size := uint32(size)
+ if !lz4block.IsValid(size) {
+ return fmt.Errorf("%w: %d", lz4errors.ErrOptionInvalidBlockSize, size)
+ }
+ w.frame.Descriptor.Flags.BlockSizeIndexSet(lz4block.Index(size))
+ return nil
+ case *CompressingReader:
+ size := uint32(size)
+ if !lz4block.IsValid(size) {
+ return fmt.Errorf("%w: %d", lz4errors.ErrOptionInvalidBlockSize, size)
+ }
+ w.frame.Descriptor.Flags.BlockSizeIndexSet(lz4block.Index(size))
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+// BlockChecksumOption enables or disables block checksum (default=false).
+func BlockChecksumOption(flag bool) Option {
+ return func(a applier) error {
+ switch w := a.(type) {
+ case nil:
+ s := fmt.Sprintf("BlockChecksumOption(%v)", flag)
+ return lz4errors.Error(s)
+ case *Writer:
+ w.frame.Descriptor.Flags.BlockChecksumSet(flag)
+ return nil
+ case *CompressingReader:
+ w.frame.Descriptor.Flags.BlockChecksumSet(flag)
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+// ChecksumOption enables/disables all blocks or content checksum (default=true).
+func ChecksumOption(flag bool) Option {
+ return func(a applier) error {
+ switch w := a.(type) {
+ case nil:
+ s := fmt.Sprintf("ChecksumOption(%v)", flag)
+ return lz4errors.Error(s)
+ case *Writer:
+ w.frame.Descriptor.Flags.ContentChecksumSet(flag)
+ return nil
+ case *CompressingReader:
+ w.frame.Descriptor.Flags.ContentChecksumSet(flag)
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+// SizeOption sets the size of the original uncompressed data (default=0). It is useful to know the size of the
+// whole uncompressed data stream.
+func SizeOption(size uint64) Option {
+ return func(a applier) error {
+ switch w := a.(type) {
+ case nil:
+ s := fmt.Sprintf("SizeOption(%d)", size)
+ return lz4errors.Error(s)
+ case *Writer:
+ w.frame.Descriptor.Flags.SizeSet(size > 0)
+ w.frame.Descriptor.ContentSize = size
+ return nil
+ case *CompressingReader:
+ w.frame.Descriptor.Flags.SizeSet(size > 0)
+ w.frame.Descriptor.ContentSize = size
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+// ConcurrencyOption sets the number of go routines used for compression.
+// If n <= 0, then the output of runtime.GOMAXPROCS(0) is used.
+func ConcurrencyOption(n int) Option {
+ if n <= 0 {
+ n = runtime.GOMAXPROCS(0)
+ }
+ return func(a applier) error {
+ switch rw := a.(type) {
+ case nil:
+ s := fmt.Sprintf("ConcurrencyOption(%d)", n)
+ return lz4errors.Error(s)
+ case *Writer:
+ rw.num = n
+ return nil
+ case *Reader:
+ rw.num = n
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+// CompressionLevel defines the level of compression to use. The higher the better, but slower, compression.
+type CompressionLevel uint32
+
+const (
+ Fast CompressionLevel = 0
+ Level1 CompressionLevel = 1 << (8 + iota)
+ Level2
+ Level3
+ Level4
+ Level5
+ Level6
+ Level7
+ Level8
+ Level9
+)
+
+// CompressionLevelOption defines the compression level (default=Fast).
+func CompressionLevelOption(level CompressionLevel) Option {
+ return func(a applier) error {
+ switch w := a.(type) {
+ case nil:
+ s := fmt.Sprintf("CompressionLevelOption(%s)", level)
+ return lz4errors.Error(s)
+ case *Writer:
+ switch level {
+ case Fast, Level1, Level2, Level3, Level4, Level5, Level6, Level7, Level8, Level9:
+ default:
+ return fmt.Errorf("%w: %d", lz4errors.ErrOptionInvalidCompressionLevel, level)
+ }
+ w.level = lz4block.CompressionLevel(level)
+ return nil
+ case *CompressingReader:
+ switch level {
+ case Fast, Level1, Level2, Level3, Level4, Level5, Level6, Level7, Level8, Level9:
+ default:
+ return fmt.Errorf("%w: %d", lz4errors.ErrOptionInvalidCompressionLevel, level)
+ }
+ w.level = lz4block.CompressionLevel(level)
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+func onBlockDone(int) {}
+
+// OnBlockDoneOption is triggered when a block has been processed. For a Writer, it is when is has been compressed,
+// for a Reader, it is when it has been uncompressed.
+func OnBlockDoneOption(handler func(size int)) Option {
+ if handler == nil {
+ handler = onBlockDone
+ }
+ return func(a applier) error {
+ switch rw := a.(type) {
+ case nil:
+ s := fmt.Sprintf("OnBlockDoneOption(%s)", reflect.TypeOf(handler).String())
+ return lz4errors.Error(s)
+ case *Writer:
+ rw.handler = handler
+ return nil
+ case *Reader:
+ rw.handler = handler
+ return nil
+ case *CompressingReader:
+ rw.handler = handler
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}
+
+// LegacyOption provides support for writing LZ4 frames in the legacy format.
+//
+// See https://github.com/lz4/lz4/blob/dev/doc/lz4_Frame_format.md#legacy-frame.
+//
+// NB. compressed Linux kernel images use a tweaked LZ4 legacy format where
+// the compressed stream is followed by the original (uncompressed) size of
+// the kernel (https://events.static.linuxfound.org/sites/events/files/lcjpcojp13_klee.pdf).
+// This is also supported as a special case.
+func LegacyOption(legacy bool) Option {
+ return func(a applier) error {
+ switch rw := a.(type) {
+ case nil:
+ s := fmt.Sprintf("LegacyOption(%v)", legacy)
+ return lz4errors.Error(s)
+ case *Writer:
+ rw.legacy = legacy
+ return nil
+ }
+ return lz4errors.ErrOptionNotApplicable
+ }
+}