/* Write as a d-gaps list */
func (bv *BitVector) writeClearedDgaps(output store.IndexOutput) error {
err := store.Stream(output).
WriteInt(-1). // mark using d-gaps
WriteInt(int32(bv.size)).
WriteInt(int32(bv.Count())).
Close()
if err != nil {
return err
}
last, numCleared := 0, bv.size-bv.Count()
for i, v := range bv.bits {
if v == byte(0xff) {
continue
}
err = output.WriteVInt(int32(i - last))
if err == nil {
err = output.WriteByte(v)
}
if err != nil {
return err
}
last = i
numCleared -= (8 - util.BitCount(v))
assert(numCleared >= 0 ||
i == len(bv.bits)-1 && numCleared == -(8-(bv.size&7)))
if numCleared <= 0 {
break
}
}
return nil
}
/* Write as a bit set */
func (bv *BitVector) writeBits(output store.IndexOutput) error {
return store.Stream(output).
WriteInt(int32(bv.size)).
WriteInt(int32(bv.Count())).
WriteBytes(bv.bits).
Close()
}
func (w *Lucene40SegmentInfoWriter) Write(dir store.Directory,
si *SegmentInfo, fis FieldInfos, ctx store.IOContext) (err error) {
filename := util.SegmentFileName(si.Name, "", LUCENE40_SI_EXTENSION)
si.AddFile(filename)
var output store.IndexOutput
output, err = dir.CreateOutput(filename, ctx)
if err != nil {
return err
}
var success = false
defer func() {
if !success {
util.CloseWhileSuppressingError(output)
si.Dir.DeleteFile(filename) // ignore error
} else {
err = mergeError(err, output.Close())
}
}()
err = codec.WriteHeader(output, LUCENE40_CODEC_NAME, LUCENE40_VERSION_CURRENT)
if err != nil {
return err
}
// Write the Lucene version that created this segment, since 3.1
err = store.Stream(output).WriteString(si.Version().String()).
WriteInt(int32(si.DocCount())).
WriteByte(func() byte {
if si.IsCompoundFile() {
return SEGMENT_INFO_YES
}
return byte((SEGMENT_INFO_NO + 256) % 256) // Go byte is non-negative, unlike Java
}()).WriteStringStringMap(si.Diagnostics()).
WriteStringStringMap(map[string]string{}).
WriteStringSet(si.Files()).Close()
if err != nil {
return err
}
success = true
return nil
}
func (nc *NormsConsumer) AddNumericField(field *FieldInfo,
iter func() func() (interface{}, bool)) (err error) {
if err = nc.meta.WriteVInt(field.Number); err != nil {
return
}
minValue, maxValue := int64(math.MaxInt64), int64(math.MinInt64)
// TODO: more efficient?
uniqueValues := newNormMap()
count := int64(0)
next := iter()
for {
nv, ok := next()
if !ok {
break
}
assert2(nv != nil, "illegal norms data for field %v, got null for value: %v", field.Name, count)
v := nv.(int64)
if v < minValue {
minValue = v
}
if v > maxValue {
maxValue = v
}
if uniqueValues != nil && uniqueValues.add(v) && uniqueValues.size > 256 {
uniqueValues = nil
}
count++
}
assert2(count == int64(nc.maxDoc),
"illegal norms data for field %v, expected %v values, got %v",
field.Name, nc.maxDoc, count)
if uniqueValues != nil && uniqueValues.size == 1 {
// 0 bpv
if err = nc.meta.WriteByte(CONST_COMPRESSED); err != nil {
return
}
if err = nc.meta.WriteLong(minValue); err != nil {
return
}
} else if uniqueValues != nil {
// small number of unique values; this is the typical case:
// we only use bpv=1,2,4,8
format := packed.PackedFormat(packed.PACKED_SINGLE_BLOCK)
bitsPerValue := packed.BitsRequired(int64(uniqueValues.size) - 1)
if bitsPerValue == 3 {
bitsPerValue = 4
} else if bitsPerValue > 4 {
bitsPerValue = 8
}
if bitsPerValue == 8 && minValue >= 0 && maxValue <= 255 {
if err = store.Stream(nc.meta).WriteByte(UNCOMPRESSED). // uncompressed []byte
WriteLong(nc.data.FilePointer()).
Close(); err != nil {
return err
}
next = iter()
for {
nv, ok := next()
if !ok {
break
}
n := byte(0)
if nv != nil {
n = byte(nv.(int64))
}
if err = nc.data.WriteByte(byte(n)); err != nil {
return err
}
}
} else {
if err = store.Stream(nc.meta).WriteByte(TABLE_COMPRESSED). // table-compressed
WriteLong(nc.data.FilePointer()).
Close(); err != nil {
return err
}
if err = nc.data.WriteVInt(packed.VERSION_CURRENT); err != nil {
return err
}
decode := uniqueValues.decodeTable()
// upgrade to power of two sized array
size := 1 << uint(bitsPerValue)
if err = nc.data.WriteVInt(int32(size)); err != nil {
return err
}
for _, v := range decode {
if err = nc.data.WriteLong(v); err != nil {
return err
}
}
for i := len(decode); i < size; i++ {
if err = nc.data.WriteLong(0); err != nil {
return err
}
}
if err = store.Stream(nc.data).WriteVInt(int32(format.Id())).
WriteVInt(int32(bitsPerValue)).
Close(); err != nil {
return err
}
writer := packed.WriterNoHeader(nc.data, format, nc.maxDoc, bitsPerValue, packed.DEFAULT_BUFFER_SIZE)
next = iter()
for {
nv, ok := next()
if !ok {
break
}
if err = writer.Add(int64(uniqueValues.ord(nv.(int64)))); err != nil {
return err
}
}
if err = writer.Finish(); err != nil {
return err
}
}
} else {
panic("not implemented yet")
}
return nil
}
