func (r *CompressingStoredFieldsReader) readField(in util.DataInput,
visitor StoredFieldVisitor, info *model.FieldInfo, bits int) (err error) {
switch bits & TYPE_MASK {
case BYTE_ARR:
panic("not implemented yet")
case STRING:
var length int
if length, err = int32AsInt(in.ReadVInt()); err != nil {
return err
}
data := make([]byte, length)
if err = in.ReadBytes(data); err != nil {
return err
}
visitor.StringField(info, string(data))
case NUMERIC_INT:
panic("not implemented yet")
case NUMERIC_FLOAT:
panic("not implemented yet")
case NUMERIC_LONG:
panic("not implemented yet")
case NUMERIC_DOUBLE:
panic("not implemented yet")
default:
panic(fmt.Sprintf("Unknown type flag: %x", bits))
}
return nil
}
func (r *Lucene41PostingsReader) DecodeTerm(longs []int64,
in util.DataInput, fieldInfo *FieldInfo,
_termState *BlockTermState, absolute bool) (err error) {
termState := _termState.Self.(*intBlockTermState)
fieldHasPositions := fieldInfo.IndexOptions() >= INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS
fieldHasOffsets := fieldInfo.IndexOptions() >= INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS
fieldHasPayloads := fieldInfo.HasPayloads()
if absolute {
termState.docStartFP = 0
termState.posStartFP = 0
termState.payStartFP = 0
}
if r.version < LUCENE41_VERSION_META_ARRAY { // backward compatibility
return r._decodeTerm(in, fieldInfo, termState)
}
termState.docStartFP += longs[0]
if fieldHasPositions {
termState.posStartFP += longs[1]
if fieldHasOffsets || fieldHasPayloads {
termState.payStartFP += longs[2]
}
}
if termState.DocFreq == 1 {
if termState.singletonDocID, err = asInt(in.ReadVInt()); err != nil {
return
}
} else {
termState.singletonDocID = -1
}
if fieldHasPositions {
if termState.TotalTermFreq > LUCENE41_BLOCK_SIZE {
if termState.lastPosBlockOffset, err = in.ReadVLong(); err != nil {
return err
}
} else {
termState.lastPosBlockOffset = -1
}
}
if termState.DocFreq > LUCENE41_BLOCK_SIZE {
if termState.skipOffset, err = in.ReadVLong(); err != nil {
return
}
} else {
termState.skipOffset = -1
}
return nil
}
func (t *FST) readLabel(in util.DataInput) (v int, err error) {
switch t.inputType {
case INPUT_TYPE_BYTE1: // Unsigned byte
if b, err := in.ReadByte(); err == nil {
v = int(b)
}
case INPUT_TYPE_BYTE2: // Unsigned short
if s, err := in.ReadShort(); err == nil {
v = int(s)
}
default:
v, err = AsInt(in.ReadVInt())
}
return v, err
}
func (r *Lucene41PostingsReader) _decodeTerm(in util.DataInput,
fieldInfo *FieldInfo, termState *intBlockTermState) (err error) {
fieldHasPositions := fieldInfo.IndexOptions() >= INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS
fieldHasOffsets := fieldInfo.IndexOptions() >= INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS
fieldHasPaylods := fieldInfo.HasPayloads()
if termState.DocFreq == 1 {
if termState.singletonDocID, err = asInt(in.ReadVInt()); err != nil {
return
}
} else {
termState.singletonDocID = -1
var n int64
if n, err = in.ReadVLong(); err != nil {
return
}
termState.docStartFP += n
}
if fieldHasPositions {
var n int64
if n, err = in.ReadVLong(); err != nil {
return
}
termState.posStartFP += n
if termState.TotalTermFreq > LUCENE41_BLOCK_SIZE {
if n, err = in.ReadVLong(); err != nil {
return
}
termState.lastPosBlockOffset += n
} else {
termState.lastPosBlockOffset = -1
}
if (fieldHasPaylods || fieldHasOffsets) && termState.TotalTermFreq >= LUCENE41_BLOCK_SIZE {
if n, err = in.ReadVLong(); err != nil {
return
}
termState.payStartFP += n
}
}
if termState.DocFreq > LUCENE41_BLOCK_SIZE {
if termState.skipOffset, err = in.ReadVLong(); err != nil {
return
}
} else {
termState.skipOffset = -1
}
return nil
}
func (out *ByteSequenceOutputs) Read(in util.DataInput) (e interface{}, err error) {
log.Printf("Reading from %v...", in)
if length, err := in.ReadVInt(); err == nil {
log.Printf("Length: %v", length)
if length == 0 {
e = out.NoOutput()
} else {
buf := make([]byte, length)
e = buf
err = in.ReadBytes(buf)
}
} else {
log.Printf("Failed to read length due to %v", err)
}
return e, err
}
/** Load a previously saved FST; maxBlockBits allows you to
* control the size of the byte[] pages used to hold the FST bytes. */
func loadFST3(in util.DataInput, outputs Outputs, maxBlockBits uint32) (fst *FST, err error) {
log.Printf("Loading FST from %v and output to %v...", in, outputs)
defer func() {
if err != nil {
log.Print("Failed to load FST.")
log.Printf("DEBUG ", err)
}
}()
fst = &FST{outputs: outputs, startNode: -1}
if maxBlockBits < 1 || maxBlockBits > 30 {
panic(fmt.Sprintf("maxBlockBits should 1..30; got %v", maxBlockBits))
}
// NOTE: only reads most recent format; we don't have
// back-compat promise for FSTs (they are experimental):
fst.version, err = codec.CheckHeader(in, FST_FILE_FORMAT_NAME, FST_VERSION_PACKED, FST_VERSION_VINT_TARGET)
if err != nil {
return fst, err
}
if b, err := in.ReadByte(); err == nil {
fst.packed = (b == 1)
} else {
return fst, err
}
if b, err := in.ReadByte(); err == nil {
if b == 1 {
// accepts empty string
// 1 KB blocks:
emptyBytes := newBytesStoreFromBits(10)
if numBytes, err := in.ReadVInt(); err == nil {
log.Printf("Number of bytes: %v", numBytes)
emptyBytes.CopyBytes(in, int64(numBytes))
// De-serialize empty-string output:
var reader BytesReader
if fst.packed {
log.Printf("Forward reader.")
reader = emptyBytes.forwardReader()
} else {
log.Printf("Reverse reader.")
reader = emptyBytes.reverseReader()
// NoOutputs uses 0 bytes when writing its output,
// so we have to check here else BytesStore gets
// angry:
if numBytes > 0 {
reader.setPosition(int64(numBytes - 1))
}
}
log.Printf("Reading final output from %v to %v...", reader, outputs)
fst.emptyOutput, err = outputs.ReadFinalOutput(reader)
}
} // else emptyOutput = nil
}
if err != nil {
return fst, err
}
if t, err := in.ReadByte(); err == nil {
switch t {
case 0:
fst.inputType = INPUT_TYPE_BYTE1
case 1:
fst.inputType = INPUT_TYPE_BYTE2
case 2:
fst.inputType = INPUT_TYPE_BYTE4
default:
panic(fmt.Sprintf("invalid input type %v", t))
}
}
if err != nil {
return fst, err
}
if fst.packed {
fst.nodeRefToAddress, err = packed.NewPackedReader(in)
if err != nil {
return fst, err
}
} // else nodeRefToAddress = nil
if fst.startNode, err = in.ReadVLong(); err == nil {
if fst.nodeCount, err = in.ReadVLong(); err == nil {
if fst.arcCount, err = in.ReadVLong(); err == nil {
if fst.arcWithOutputCount, err = in.ReadVLong(); err == nil {
if numBytes, err := in.ReadVLong(); err == nil {
if fst.bytes, err = newBytesStoreFromInput(in, numBytes, 1<<maxBlockBits); err == nil {
fst.NO_OUTPUT = outputs.NoOutput()
err = fst.cacheRootArcs()
// NOTE: bogus because this is only used during
// building; we need to break out mutable FST from
// immutable
// fst.allowArrayArcs = false
}
}
}
}
}
}
return fst, err
}
