func (np *NormsProducer) readFields(meta store.IndexInput, infos FieldInfos) (err error) {
var fieldNumber int32
if fieldNumber, err = meta.ReadVInt(); err != nil {
return err
}
for fieldNumber != -1 {
info := infos.FieldInfoByNumber(int(fieldNumber))
if info == nil {
return errors.New(fmt.Sprintf("Invalid field number: %v (resource=%v)", fieldNumber, meta))
} else if !info.HasNorms() {
return errors.New(fmt.Sprintf("Invalid field: %v (resource=%v)", info.Name, meta))
}
var format byte
if format, err = meta.ReadByte(); err != nil {
return err
}
var offset int64
if offset, err = meta.ReadLong(); err != nil {
return err
}
entry := &NormsEntry{
format: format,
offset: offset,
}
if format > UNCOMPRESSED {
return errors.New(fmt.Sprintf("Unknown format: %v, input=%v", format, meta))
}
np.norms[int(fieldNumber)] = entry
if fieldNumber, err = meta.ReadVInt(); err != nil {
return err
}
}
return nil
}
/* Reads but does not decode the byte[] blob holding
metadata for the current terms block */
func (r *Lucene41PostingsReader) ReadTermsBlock(termsIn store.IndexInput,
fieldInfo model.FieldInfo, _termState *BlockTermState) (err error) {
termState := _termState.Self.(*intBlockTermState)
numBytes, err := asInt(termsIn.ReadVInt())
if err != nil {
return err
}
if termState.bytes == nil {
// TODO over-allocate
termState.bytes = make([]byte, numBytes)
termState.bytesReader = store.NewEmptyByteArrayDataInput()
} else if len(termState.bytes) < numBytes {
// TODO over-allocate
termState.bytes = make([]byte, numBytes)
}
err = termsIn.ReadBytes(termState.bytes)
if err != nil {
return err
}
termState.bytesReader.Reset(termState.bytes)
return nil
}
func readBytesRef(in store.IndexInput) ([]byte, error) {
length, err := asInt(in.ReadVInt())
if err != nil {
return nil, err
}
bytes := make([]byte, length)
if err = in.ReadBytes(bytes); err != nil {
return nil, err
}
return bytes, nil
}
func (r *Lucene41PostingsReader) Init(termsIn store.IndexInput) error {
log.Printf("Initializing from: %v", termsIn)
// Make sure we are talking to the matching postings writer
_, err := codec.CheckHeader(termsIn, LUCENE41_TERMS_CODEC, LUCENE41_VERSION_START, LUCENE41_VERSION_CURRENT)
if err != nil {
return err
}
indexBlockSize, err := termsIn.ReadVInt()
if err != nil {
return err
}
log.Printf("Index block size: %v", indexBlockSize)
if indexBlockSize != LUCENE41_BLOCK_SIZE {
panic(fmt.Sprintf("index-time BLOCK_SIZE (%v) != read-time BLOCK_SIZE (%v)", indexBlockSize, LUCENE41_BLOCK_SIZE))
}
return nil
}
/**
* Read values that have been written using variable-length encoding instead of bit-packing.
*/
func readVIntBlock(docIn store.IndexInput, docBuffer []int,
freqBuffer []int, num int, indexHasFreq bool) (err error) {
if indexHasFreq {
for i := 0; i < num; i++ {
code, err := asInt(docIn.ReadVInt())
if err != nil {
return err
}
docBuffer[i] = int(uint(code) >> 1)
if (code & 1) != 0 {
freqBuffer[i] = 1
} else {
freqBuffer[i], err = asInt(docIn.ReadVInt())
if err != nil {
return err
}
}
}
} else {
for i := 0; i < num; i++ {
docBuffer[i], err = asInt(docIn.ReadVInt())
if err != nil {
return err
}
}
}
return nil
}
/*
Lucene42DocValuesProducer.java/4.5.1/L138
*/
func (dvp *Lucene42DocValuesProducer) readFields(meta store.IndexInput) (err error) {
var fieldNumber int
var fieldType byte
fieldNumber, err = asInt(meta.ReadVInt())
for fieldNumber != -1 && err == nil {
fieldType, err = meta.ReadByte()
if err != nil {
break
}
switch fieldType {
case LUCENE42_DV_NUMBER:
entry := NumericEntry{}
entry.offset, err = meta.ReadLong()
if err != nil {
return err
}
entry.format, err = meta.ReadByte()
if err != nil {
return err
}
switch entry.format {
case LUCENE42_DV_DELTA_COMPRESSED:
case LUCENE42_DV_TABLE_COMPRESSED:
case LUCENE42_DV_GCD_COMPRESSED:
case LUCENE42_DV_UNCOMPRESSED:
default:
return errors.New(fmt.Sprintf("Unknown format: %v, input=%v", entry.format, meta))
}
if entry.format != LUCENE42_DV_UNCOMPRESSED {
entry.packedIntsVersion, err = asInt(meta.ReadVInt())
if err != nil {
return err
}
}
dvp.numerics[fieldNumber] = entry
case LUCENE42_DV_BYTES:
panic("not implemented yet")
case LUCENE42_DV_FST:
panic("not implemented yet")
default:
return errors.New(fmt.Sprintf("invalid entry type: %v, input=%v", fieldType, meta))
}
fieldNumber, err = asInt(meta.ReadVInt())
}
return
}
func newCompressingStoredFieldsIndexReader(fieldsIndexIn store.IndexInput,
si *model.SegmentInfo) (r *CompressingStoredFieldsIndexReader, err error) {
r = &CompressingStoredFieldsIndexReader{}
r.maxDoc = si.DocCount()
r.docBases = make([]int, 0, 16)
r.startPointers = make([]int64, 0, 16)
r.avgChunkDocs = make([]int, 0, 16)
r.avgChunkSizes = make([]int64, 0, 16)
r.docBasesDeltas = make([]packed.PackedIntsReader, 0, 16)
r.startPointersDeltas = make([]packed.PackedIntsReader, 0, 16)
packedIntsVersion, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
for blockCount := 0; ; blockCount++ {
numChunks, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
if numChunks == 0 {
break
}
{ // doc bases
n, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
r.docBases = append(r.docBases, int(n))
n, err = fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
r.avgChunkDocs = append(r.avgChunkDocs, int(n))
bitsPerDocBase, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
if bitsPerDocBase > 32 {
return nil, errors.New(fmt.Sprintf("Corrupted bitsPerDocBase (resource=%v)", fieldsIndexIn))
}
pr, err := packed.NewPackedReaderNoHeader(fieldsIndexIn, packed.PACKED, packedIntsVersion, numChunks, uint32(bitsPerDocBase))
if err != nil {
return nil, err
}
r.docBasesDeltas = append(r.docBasesDeltas, pr)
}
{ // start pointers
n, err := fieldsIndexIn.ReadVLong()
if err != nil {
return nil, err
}
r.startPointers = append(r.startPointers, n)
n, err = fieldsIndexIn.ReadVLong()
if err != nil {
return nil, err
}
r.avgChunkSizes = append(r.avgChunkSizes, n)
bitsPerStartPointer, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
if bitsPerStartPointer > 64 {
return nil, errors.New(fmt.Sprintf("Corrupted bitsPerStartPonter (resource=%v)", fieldsIndexIn))
}
pr, err := packed.NewPackedReaderNoHeader(fieldsIndexIn, packed.PACKED, packedIntsVersion, numChunks, uint32(bitsPerStartPointer))
if err != nil {
return nil, err
}
r.startPointersDeltas = append(r.startPointersDeltas, pr)
}
}
return r, nil
}