func (c *columnint64) Index() *bitmap.Bitmap {
	return &c.fill
}
Index returns the fill list for the column
package column
import (
	"github.com/kelindar/bitmap"
	"github.com/kelindar/column/commit"
)
type columnfloat32 struct {
	fill bitmap.Bitmap  
	data []float32      
}
func makeFloat32s() Column {
	return &columnfloat32{
		fill: make(bitmap.Bitmap, 0, 4),
		data: make([]float32, 0, 64),
	}
}
func (c *columnfloat32) Grow(idx uint32) {
	if idx < uint32(len(c.data)) {
		return
	}
	if idx < uint32(cap(c.data)) {
		c.fill.Grow(idx)
		c.data = c.data[:idx+1]
		return
	}
	c.fill.Grow(idx)
	clone := make([]float32, idx+1, capacityFor(idx+1))
	copy(clone, c.data)
	c.data = clone
}
func (c *columnfloat32) Apply(r *commit.Reader) {
	for r.Next() {
		switch r.Type {
		case commit.Put:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			c.data[r.Offset] = r.Float32()
		case commit.Add:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			value := c.data[r.Offset] + r.Float32()
			c.data[r.Offset] = value
			r.SwapFloat32(value)
		case commit.Delete:
			c.fill.Remove(r.Index())
		}
	}
}
func (c *columnfloat32) Contains(idx uint32) bool {
	return c.fill.Contains(idx)
}
func (c *columnfloat32) Index() *bitmap.Bitmap {
	return &c.fill
}
func (c *columnfloat32) Value(idx uint32) (v interface{}, ok bool) {
	v = float32(0)
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = c.data[idx], true
	}
	return
}
func (c *columnfloat32) LoadFloat64(idx uint32) (v float64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = float64(c.data[idx]), true
	}
	return
}
func (c *columnfloat32) LoadInt64(idx uint32) (v int64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = int64(c.data[idx]), true
	}
	return
}
func (c *columnfloat32) LoadUint64(idx uint32) (v uint64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = uint64(c.data[idx]), true
	}
	return
}
func (c *columnfloat32) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) bool {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
	})
}
func (c *columnfloat32) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
	})
}
func (c *columnfloat32) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
	})
}
func (cur *Cursor) SetFloat32(value float32) {
	cur.update.PutFloat32(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddFloat32(amount float32) {
	cur.update.PutFloat32(commit.Add, cur.idx, amount)
}
func (cur *Cursor) SetFloat32At(column string, value float32) {
	cur.txn.bufferFor(column).PutFloat32(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddFloat32At(column string, amount float32) {
	cur.txn.bufferFor(column).PutFloat32(commit.Add, cur.idx, amount)
}
type columnfloat64 struct {
	fill bitmap.Bitmap  
	data []float64      
}
func makeFloat64s() Column {
	return &columnfloat64{
		fill: make(bitmap.Bitmap, 0, 4),
		data: make([]float64, 0, 64),
	}
}
func (c *columnfloat64) Grow(idx uint32) {
	if idx < uint32(len(c.data)) {
		return
	}
	if idx < uint32(cap(c.data)) {
		c.fill.Grow(idx)
		c.data = c.data[:idx+1]
		return
	}
	c.fill.Grow(idx)
	clone := make([]float64, idx+1, capacityFor(idx+1))
	copy(clone, c.data)
	c.data = clone
}
func (c *columnfloat64) Apply(r *commit.Reader) {
	for r.Next() {
		switch r.Type {
		case commit.Put:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			c.data[r.Offset] = r.Float64()
		case commit.Add:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			value := c.data[r.Offset] + r.Float64()
			c.data[r.Offset] = value
			r.SwapFloat64(value)
		case commit.Delete:
			c.fill.Remove(r.Index())
		}
	}
}
func (c *columnfloat64) Contains(idx uint32) bool {
	return c.fill.Contains(idx)
}
func (c *columnfloat64) Index() *bitmap.Bitmap {
	return &c.fill
}
func (c *columnfloat64) Value(idx uint32) (v interface{}, ok bool) {
	v = float64(0)
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = c.data[idx], true
	}
	return
}
func (c *columnfloat64) LoadFloat64(idx uint32) (v float64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = float64(c.data[idx]), true
	}
	return
}
func (c *columnfloat64) LoadInt64(idx uint32) (v int64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = int64(c.data[idx]), true
	}
	return
}
func (c *columnfloat64) LoadUint64(idx uint32) (v uint64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = uint64(c.data[idx]), true
	}
	return
}
func (c *columnfloat64) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) bool {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
	})
}
func (c *columnfloat64) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
	})
}
func (c *columnfloat64) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
	})
}
func (cur *Cursor) SetFloat64(value float64) {
	cur.update.PutFloat64(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddFloat64(amount float64) {
	cur.update.PutFloat64(commit.Add, cur.idx, amount)
}
func (cur *Cursor) SetFloat64At(column string, value float64) {
	cur.txn.bufferFor(column).PutFloat64(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddFloat64At(column string, amount float64) {
	cur.txn.bufferFor(column).PutFloat64(commit.Add, cur.idx, amount)
}
type columnint struct {
	fill bitmap.Bitmap  
	data []int          
}
func makeInts() Column {
	return &columnint{
		fill: make(bitmap.Bitmap, 0, 4),
		data: make([]int, 0, 64),
	}
}
func (c *columnint) Grow(idx uint32) {
	if idx < uint32(len(c.data)) {
		return
	}
	if idx < uint32(cap(c.data)) {
		c.fill.Grow(idx)
		c.data = c.data[:idx+1]
		return
	}
	c.fill.Grow(idx)
	clone := make([]int, idx+1, capacityFor(idx+1))
	copy(clone, c.data)
	c.data = clone
}
func (c *columnint) Apply(r *commit.Reader) {
	for r.Next() {
		switch r.Type {
		case commit.Put:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			c.data[r.Offset] = r.Int()
		case commit.Add:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			value := c.data[r.Offset] + r.Int()
			c.data[r.Offset] = value
			r.SwapInt(value)
		case commit.Delete:
			c.fill.Remove(r.Index())
		}
	}
}
func (c *columnint) Contains(idx uint32) bool {
	return c.fill.Contains(idx)
}
func (c *columnint) Index() *bitmap.Bitmap {
	return &c.fill
}
func (c *columnint) Value(idx uint32) (v interface{}, ok bool) {
	v = int(0)
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = c.data[idx], true
	}
	return
}
func (c *columnint) LoadFloat64(idx uint32) (v float64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = float64(c.data[idx]), true
	}
	return
}
func (c *columnint) LoadInt64(idx uint32) (v int64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = int64(c.data[idx]), true
	}
	return
}
func (c *columnint) LoadUint64(idx uint32) (v uint64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = uint64(c.data[idx]), true
	}
	return
}
func (c *columnint) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) bool {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
	})
}
func (c *columnint) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
	})
}
func (c *columnint) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
	})
}
func (cur *Cursor) SetInt(value int) {
	cur.update.PutInt(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddInt(amount int) {
	cur.update.PutInt(commit.Add, cur.idx, amount)
}
func (cur *Cursor) SetIntAt(column string, value int) {
	cur.txn.bufferFor(column).PutInt(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddIntAt(column string, amount int) {
	cur.txn.bufferFor(column).PutInt(commit.Add, cur.idx, amount)
}
type columnint16 struct {
	fill bitmap.Bitmap  
	data []int16        
}
func makeInt16s() Column {
	return &columnint16{
		fill: make(bitmap.Bitmap, 0, 4),
		data: make([]int16, 0, 64),
	}
}
func (c *columnint16) Grow(idx uint32) {
	if idx < uint32(len(c.data)) {
		return
	}
	if idx < uint32(cap(c.data)) {
		c.fill.Grow(idx)
		c.data = c.data[:idx+1]
		return
	}
	c.fill.Grow(idx)
	clone := make([]int16, idx+1, capacityFor(idx+1))
	copy(clone, c.data)
	c.data = clone
}
func (c *columnint16) Apply(r *commit.Reader) {
	for r.Next() {
		switch r.Type {
		case commit.Put:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			c.data[r.Offset] = r.Int16()
		case commit.Add:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			value := c.data[r.Offset] + r.Int16()
			c.data[r.Offset] = value
			r.SwapInt16(value)
		case commit.Delete:
			c.fill.Remove(r.Index())
		}
	}
}
func (c *columnint16) Contains(idx uint32) bool {
	return c.fill.Contains(idx)
}
func (c *columnint16) Index() *bitmap.Bitmap {
	return &c.fill
}
func (c *columnint16) Value(idx uint32) (v interface{}, ok bool) {
	v = int16(0)
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = c.data[idx], true
	}
	return
}
func (c *columnint16) LoadFloat64(idx uint32) (v float64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = float64(c.data[idx]), true
	}
	return
}
func (c *columnint16) LoadInt64(idx uint32) (v int64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = int64(c.data[idx]), true
	}
	return
}
func (c *columnint16) LoadUint64(idx uint32) (v uint64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = uint64(c.data[idx]), true
	}
	return
}
func (c *columnint16) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) bool {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
	})
}
func (c *columnint16) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
	})
}
func (c *columnint16) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
	})
}
func (cur *Cursor) SetInt16(value int16) {
	cur.update.PutInt16(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddInt16(amount int16) {
	cur.update.PutInt16(commit.Add, cur.idx, amount)
}
func (cur *Cursor) SetInt16At(column string, value int16) {
	cur.txn.bufferFor(column).PutInt16(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddInt16At(column string, amount int16) {
	cur.txn.bufferFor(column).PutInt16(commit.Add, cur.idx, amount)
}
type columnint32 struct {
	fill bitmap.Bitmap  
	data []int32        
}
func makeInt32s() Column {
	return &columnint32{
		fill: make(bitmap.Bitmap, 0, 4),
		data: make([]int32, 0, 64),
	}
}
func (c *columnint32) Grow(idx uint32) {
	if idx < uint32(len(c.data)) {
		return
	}
	if idx < uint32(cap(c.data)) {
		c.fill.Grow(idx)
		c.data = c.data[:idx+1]
		return
	}
	c.fill.Grow(idx)
	clone := make([]int32, idx+1, capacityFor(idx+1))
	copy(clone, c.data)
	c.data = clone
}
func (c *columnint32) Apply(r *commit.Reader) {
	for r.Next() {
		switch r.Type {
		case commit.Put:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			c.data[r.Offset] = r.Int32()
		case commit.Add:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			value := c.data[r.Offset] + r.Int32()
			c.data[r.Offset] = value
			r.SwapInt32(value)
		case commit.Delete:
			c.fill.Remove(r.Index())
		}
	}
}
func (c *columnint32) Contains(idx uint32) bool {
	return c.fill.Contains(idx)
}
func (c *columnint32) Index() *bitmap.Bitmap {
	return &c.fill
}
func (c *columnint32) Value(idx uint32) (v interface{}, ok bool) {
	v = int32(0)
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = c.data[idx], true
	}
	return
}
func (c *columnint32) LoadFloat64(idx uint32) (v float64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = float64(c.data[idx]), true
	}
	return
}
func (c *columnint32) LoadInt64(idx uint32) (v int64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = int64(c.data[idx]), true
	}
	return
}
func (c *columnint32) LoadUint64(idx uint32) (v uint64, ok bool) {
	if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
		v, ok = uint64(c.data[idx]), true
	}
	return
}
func (c *columnint32) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) bool {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
	})
}
func (c *columnint32) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
	})
}
func (c *columnint32) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
	index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
	index.Filter(func(idx uint32) (match bool) {
		idx = offset + idx
		return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
	})
}
func (cur *Cursor) SetInt32(value int32) {
	cur.update.PutInt32(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddInt32(amount int32) {
	cur.update.PutInt32(commit.Add, cur.idx, amount)
}
func (cur *Cursor) SetInt32At(column string, value int32) {
	cur.txn.bufferFor(column).PutInt32(commit.Put, cur.idx, value)
}
func (cur *Cursor) AddInt32At(column string, amount int32) {
	cur.txn.bufferFor(column).PutInt32(commit.Add, cur.idx, amount)
}
type columnint64 struct {
	fill bitmap.Bitmap  
	data []int64        
}
func makeInt64s() Column {
	return &columnint64{
		fill: make(bitmap.Bitmap, 0, 4),
		data: make([]int64, 0, 64),
	}
}
func (c *columnint64) Grow(idx uint32) {
	if idx < uint32(len(c.data)) {
		return
	}
	if idx < uint32(cap(c.data)) {
		c.fill.Grow(idx)
		c.data = c.data[:idx+1]
		return
	}
	c.fill.Grow(idx)
	clone := make([]int64, idx+1, capacityFor(idx+1))
	copy(clone, c.data)
	c.data = clone
}
func (c *columnint64) Apply(r *commit.Reader) {
	for r.Next() {
		switch r.Type {
		case commit.Put:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			c.data[r.Offset] = r.Int64()
		case commit.Add:
			c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
			value := c.data[r.Offset] + r.Int64()
			c.data[r.Offset] = value
			r.SwapInt64(value)
		case commit.Delete:
			c.fill.Remove(r.Index())
		}
	}
}
func (c *columnint64) Contains(idx uint32) bool {
	return c.fill.Contains(idx)
}