func NewForUtil(in DataInput) (fu ForUtil, err error) {
self := ForUtil{}
packedIntsVersion, err := in.ReadVInt()
if err != nil {
return self, err
}
packed.CheckVersion(packedIntsVersion)
self.encodedSizes = make([]int32, 33)
self.encoders = make([]packed.PackedIntsEncoder, 33)
self.decoders = make([]packed.PackedIntsDecoder, 33)
self.iterations = make([]int32, 33)
for bpv := 1; bpv <= 32; bpv++ {
code, err := in.ReadVInt()
if err != nil {
return self, err
}
formatId := uint32(code) >> 5
bitsPerValue := (uint32(code) & 31) + 1
format := packed.PackedFormat(formatId)
// assert format.isSupported(bitsPerValue)
self.encodedSizes[bpv] = encodedSize(format, packedIntsVersion, bitsPerValue)
self.encoders[bpv] = packed.GetPackedIntsEncoder(format, packedIntsVersion, bitsPerValue)
self.decoders[bpv] = packed.GetPackedIntsDecoder(format, packedIntsVersion, bitsPerValue)
self.iterations[bpv] = computeIterations(self.decoders[bpv])
}
return self, nil
}
/* Create a new ForUtil instance and save state into out. */
func NewForUtilInto(accetableOverheadRatio float32, out util.DataOutput) (*ForUtil, error) {
ans, err := &ForUtil{}, out.WriteVInt(packed.VERSION_CURRENT)
if err != nil {
return ans, err
}
ans.encodedSizes = make([]int32, 33)
ans.encoders = make([]packed.PackedIntsEncoder, 33)
ans.decoders = make([]packed.PackedIntsDecoder, 33)
ans.iterations = make([]int32, 33)
packedIntsVersion := int32(packed.VERSION_CURRENT)
for bpv := 1; bpv <= 32; bpv++ {
formatAndBits := packed.FastestFormatAndBits(
LUCENE41_BLOCK_SIZE, bpv, accetableOverheadRatio)
format := formatAndBits.Format
bitsPerValue := formatAndBits.BitsPerValue
assert(format.IsSupported(bitsPerValue))
assert(bitsPerValue <= 32)
ans.encodedSizes[bpv] = encodedSize(format, packedIntsVersion, uint32(bitsPerValue))
ans.encoders[bpv] = packed.GetPackedIntsEncoder(format, packedIntsVersion, uint32(bitsPerValue))
ans.decoders[bpv] = packed.GetPackedIntsDecoder(format, packedIntsVersion, uint32(bitsPerValue))
ans.iterations[bpv] = computeIterations(ans.decoders[bpv])
err = out.WriteVInt(int32(format.Id()<<5 | (bitsPerValue - 1)))
if err != nil {
return ans, err
}
}
return ans, err
}
func computeMaxDataSize() int {
maxDataSize := 0
// for each version
for version := packed.PACKED_VERSION_START; version <= packed.PACKED_VERSION_CURRENT; version++ {
// for each packed format
for format := packed.PACKED; format <= packed.PACKED_SINGLE_BLOCK; format++ {
// for each bit-per-value
for bpv := uint32(1); bpv <= 32; bpv++ {
if !packed.PackedFormat(format).IsSupported(bpv) {
continue
}
decoder := packed.GetPackedIntsDecoder(packed.PackedFormat(format), int32(version), bpv)
iterations := int(computeIterations(decoder))
if n := iterations * decoder.ByteValueCount(); n > maxDataSize {
maxDataSize = n
}
}
}
}
return maxDataSize
}