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 newBytesStoreFromInput(in util.DataInput, numBytes int64, maxBlockSize uint32) (bs *BytesStore, err error) {
var blockSize uint32 = 2
var blockBits uint32 = 1
for int64(blockSize) < numBytes && blockSize < maxBlockSize {
blockSize *= 2
blockBits++
}
self := newBytesStore()
self.blockBits = blockBits
self.blockSize = blockSize
self.blockMask = blockSize - 1
left := numBytes
for left > 0 {
chunk := blockSize
if left < int64(chunk) {
chunk = uint32(left)
}
block := make([]byte, chunk)
err = in.ReadBytes(block)
if err != nil {
return nil, err
}
self.blocks = append(self.blocks, block)
left -= int64(chunk)
}
// So .getPosition still works
self.nextWrite = uint32(len(self.blocks[len(self.blocks)-1]))
return self, 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
}