parent
b50dee5a61
commit
9591185c8f
@ -0,0 +1,20 @@ |
||||
kind: pipeline |
||||
name: default |
||||
|
||||
workspace: |
||||
base: /go |
||||
path: src/github.com/RoaringBitmap/roaring |
||||
|
||||
steps: |
||||
- name: test |
||||
image: golang |
||||
commands: |
||||
- go get -t |
||||
- go test |
||||
- go test -race -run TestConcurrent* |
||||
- go build -tags appengine |
||||
- go test -tags appengine |
||||
- GOARCH=386 go build |
||||
- GOARCH=386 go test |
||||
- GOARCH=arm go build |
||||
- GOARCH=arm64 go build |
@ -0,0 +1,161 @@ |
||||
package roaring |
||||
|
||||
import ( |
||||
"encoding/binary" |
||||
"io" |
||||
) |
||||
|
||||
type byteInput interface { |
||||
// next returns a slice containing the next n bytes from the buffer,
|
||||
// advancing the buffer as if the bytes had been returned by Read.
|
||||
next(n int) ([]byte, error) |
||||
// readUInt32 reads uint32 with LittleEndian order
|
||||
readUInt32() (uint32, error) |
||||
// readUInt16 reads uint16 with LittleEndian order
|
||||
readUInt16() (uint16, error) |
||||
// getReadBytes returns read bytes
|
||||
getReadBytes() int64 |
||||
// skipBytes skips exactly n bytes
|
||||
skipBytes(n int) error |
||||
} |
||||
|
||||
func newByteInputFromReader(reader io.Reader) byteInput { |
||||
return &byteInputAdapter{ |
||||
r: reader, |
||||
readBytes: 0, |
||||
} |
||||
} |
||||
|
||||
func newByteInput(buf []byte) byteInput { |
||||
return &byteBuffer{ |
||||
buf: buf, |
||||
off: 0, |
||||
} |
||||
} |
||||
|
||||
type byteBuffer struct { |
||||
buf []byte |
||||
off int |
||||
} |
||||
|
||||
// next returns a slice containing the next n bytes from the reader
|
||||
// If there are fewer bytes than the given n, io.ErrUnexpectedEOF will be returned
|
||||
func (b *byteBuffer) next(n int) ([]byte, error) { |
||||
m := len(b.buf) - b.off |
||||
|
||||
if n > m { |
||||
return nil, io.ErrUnexpectedEOF |
||||
} |
||||
|
||||
data := b.buf[b.off : b.off+n] |
||||
b.off += n |
||||
|
||||
return data, nil |
||||
} |
||||
|
||||
// readUInt32 reads uint32 with LittleEndian order
|
||||
func (b *byteBuffer) readUInt32() (uint32, error) { |
||||
if len(b.buf)-b.off < 4 { |
||||
return 0, io.ErrUnexpectedEOF |
||||
} |
||||
|
||||
v := binary.LittleEndian.Uint32(b.buf[b.off:]) |
||||
b.off += 4 |
||||
|
||||
return v, nil |
||||
} |
||||
|
||||
// readUInt16 reads uint16 with LittleEndian order
|
||||
func (b *byteBuffer) readUInt16() (uint16, error) { |
||||
if len(b.buf)-b.off < 2 { |
||||
return 0, io.ErrUnexpectedEOF |
||||
} |
||||
|
||||
v := binary.LittleEndian.Uint16(b.buf[b.off:]) |
||||
b.off += 2 |
||||
|
||||
return v, nil |
||||
} |
||||
|
||||
// getReadBytes returns read bytes
|
||||
func (b *byteBuffer) getReadBytes() int64 { |
||||
return int64(b.off) |
||||
} |
||||
|
||||
// skipBytes skips exactly n bytes
|
||||
func (b *byteBuffer) skipBytes(n int) error { |
||||
m := len(b.buf) - b.off |
||||
|
||||
if n > m { |
||||
return io.ErrUnexpectedEOF |
||||
} |
||||
|
||||
b.off += n |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// reset resets the given buffer with a new byte slice
|
||||
func (b *byteBuffer) reset(buf []byte) { |
||||
b.buf = buf |
||||
b.off = 0 |
||||
} |
||||
|
||||
type byteInputAdapter struct { |
||||
r io.Reader |
||||
readBytes int |
||||
} |
||||
|
||||
// next returns a slice containing the next n bytes from the buffer,
|
||||
// advancing the buffer as if the bytes had been returned by Read.
|
||||
func (b *byteInputAdapter) next(n int) ([]byte, error) { |
||||
buf := make([]byte, n) |
||||
m, err := io.ReadAtLeast(b.r, buf, n) |
||||
b.readBytes += m |
||||
|
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return buf, nil |
||||
} |
||||
|
||||
// readUInt32 reads uint32 with LittleEndian order
|
||||
func (b *byteInputAdapter) readUInt32() (uint32, error) { |
||||
buf, err := b.next(4) |
||||
|
||||
if err != nil { |
||||
return 0, err |
||||
} |
||||
|
||||
return binary.LittleEndian.Uint32(buf), nil |
||||
} |
||||
|
||||
// readUInt16 reads uint16 with LittleEndian order
|
||||
func (b *byteInputAdapter) readUInt16() (uint16, error) { |
||||
buf, err := b.next(2) |
||||
|
||||
if err != nil { |
||||
return 0, err |
||||
} |
||||
|
||||
return binary.LittleEndian.Uint16(buf), nil |
||||
} |
||||
|
||||
// getReadBytes returns read bytes
|
||||
func (b *byteInputAdapter) getReadBytes() int64 { |
||||
return int64(b.readBytes) |
||||
} |
||||
|
||||
// skipBytes skips exactly n bytes
|
||||
func (b *byteInputAdapter) skipBytes(n int) error { |
||||
_, err := b.next(n) |
||||
|
||||
return err |
||||
} |
||||
|
||||
// reset resets the given buffer with a new stream
|
||||
func (b *byteInputAdapter) reset(stream io.Reader) { |
||||
b.r = stream |
||||
b.readBytes = 0 |
||||
} |
@ -0,0 +1,11 @@ |
||||
// +build go1.9
|
||||
// "go1.9", from Go version 1.9 onward
|
||||
// See https://golang.org/pkg/go/build/#hdr-Build_Constraints
|
||||
|
||||
package roaring |
||||
|
||||
import "math/bits" |
||||
|
||||
func countLeadingZeros(x uint64) int { |
||||
return bits.LeadingZeros64(x) |
||||
} |
@ -0,0 +1,36 @@ |
||||
// +build !go1.9
|
||||
|
||||
package roaring |
||||
|
||||
// LeadingZeroBits returns the number of consecutive most significant zero
|
||||
// bits of x.
|
||||
func countLeadingZeros(i uint64) int { |
||||
if i == 0 { |
||||
return 64 |
||||
} |
||||
n := 1 |
||||
x := uint32(i >> 32) |
||||
if x == 0 { |
||||
n += 32 |
||||
x = uint32(i) |
||||
} |
||||
if (x >> 16) == 0 { |
||||
n += 16 |
||||
x <<= 16 |
||||
} |
||||
if (x >> 24) == 0 { |
||||
n += 8 |
||||
x <<= 8 |
||||
} |
||||
if x>>28 == 0 { |
||||
n += 4 |
||||
x <<= 4 |
||||
} |
||||
if x>>30 == 0 { |
||||
n += 2 |
||||
x <<= 2 |
||||
|
||||
} |
||||
n -= int(x >> 31) |
||||
return n |
||||
} |
@ -0,0 +1,16 @@ |
||||
module github.com/RoaringBitmap/roaring |
||||
|
||||
go 1.12 |
||||
|
||||
require ( |
||||
github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2 |
||||
github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31 // indirect |
||||
github.com/golang/snappy v0.0.1 // indirect |
||||
github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99 // indirect |
||||
github.com/jtolds/gls v4.20.0+incompatible // indirect |
||||
github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae |
||||
github.com/philhofer/fwd v1.0.0 // indirect |
||||
github.com/stretchr/testify v1.4.0 |
||||
github.com/tinylib/msgp v1.1.0 |
||||
github.com/willf/bitset v1.1.10 |
||||
) |
@ -0,0 +1,30 @@ |
||||
github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= |
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||
github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2 h1:Ujru1hufTHVb++eG6OuNDKMxZnGIvF6o/u8q/8h2+I4= |
||||
github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE= |
||||
github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31 h1:gclg6gY70GLy3PbkQ1AERPfmLMMagS60DKF78eWwLn8= |
||||
github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24= |
||||
github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4= |
||||
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= |
||||
github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99 h1:twflg0XRTjwKpxb/jFExr4HGq6on2dEOmnL6FV+fgPw= |
||||
github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= |
||||
github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= |
||||
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= |
||||
github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae h1:VeRdUYdCw49yizlSbMEn2SZ+gT+3IUKx8BqxyQdz+BY= |
||||
github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg= |
||||
github.com/philhofer/fwd v1.0.0 h1:UbZqGr5Y38ApvM/V/jEljVxwocdweyH+vmYvRPBnbqQ= |
||||
github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= |
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= |
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= |
||||
github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= |
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= |
||||
github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= |
||||
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= |
||||
github.com/tinylib/msgp v1.1.0 h1:9fQd+ICuRIu/ue4vxJZu6/LzxN0HwMds2nq/0cFvxHU= |
||||
github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= |
||||
github.com/willf/bitset v1.1.10 h1:NotGKqX0KwQ72NUzqrjZq5ipPNDQex9lo3WpaS8L2sc= |
||||
github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= |
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= |
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= |
||||
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= |
||||
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= |
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,163 +0,0 @@ |
||||
package roaring |
||||
|
||||
import ( |
||||
"fmt" |
||||
) |
||||
|
||||
// common to rle32.go and rle16.go
|
||||
|
||||
// rleVerbose controls whether p() prints show up.
|
||||
// The testing package sets this based on
|
||||
// testing.Verbose().
|
||||
var rleVerbose bool |
||||
|
||||
// p is a shorthand for fmt.Printf with beginning and
|
||||
// trailing newlines. p() makes it easy
|
||||
// to add diagnostic print statements.
|
||||
func p(format string, args ...interface{}) { |
||||
if rleVerbose { |
||||
fmt.Printf("\n"+format+"\n", args...) |
||||
} |
||||
} |
||||
|
||||
// MaxUint32 is the largest uint32 value.
|
||||
const MaxUint32 = 4294967295 |
||||
|
||||
// MaxUint16 is the largest 16 bit unsigned int.
|
||||
// This is the largest value an interval16 can store.
|
||||
const MaxUint16 = 65535 |
||||
|
||||
// searchOptions allows us to accelerate runContainer32.search with
|
||||
// prior knowledge of (mostly lower) bounds. This is used by Union
|
||||
// and Intersect.
|
||||
type searchOptions struct { |
||||
// start here instead of at 0
|
||||
startIndex int64 |
||||
|
||||
// upper bound instead of len(rc.iv);
|
||||
// endxIndex == 0 means ignore the bound and use
|
||||
// endxIndex == n ==len(rc.iv) which is also
|
||||
// naturally the default for search()
|
||||
// when opt = nil.
|
||||
endxIndex int64 |
||||
} |
||||
|
||||
// And finds the intersection of rc and b.
|
||||
func (rc *runContainer32) And(b *Bitmap) *Bitmap { |
||||
out := NewBitmap() |
||||
for _, p := range rc.iv { |
||||
for i := p.start; i <= p.last; i++ { |
||||
if b.Contains(i) { |
||||
out.Add(i) |
||||
} |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Xor returns the exclusive-or of rc and b.
|
||||
func (rc *runContainer32) Xor(b *Bitmap) *Bitmap { |
||||
out := b.Clone() |
||||
for _, p := range rc.iv { |
||||
for v := p.start; v <= p.last; v++ { |
||||
if out.Contains(v) { |
||||
out.RemoveRange(uint64(v), uint64(v+1)) |
||||
} else { |
||||
out.Add(v) |
||||
} |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Or returns the union of rc and b.
|
||||
func (rc *runContainer32) Or(b *Bitmap) *Bitmap { |
||||
out := b.Clone() |
||||
for _, p := range rc.iv { |
||||
for v := p.start; v <= p.last; v++ { |
||||
out.Add(v) |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// trial is used in the randomized testing of runContainers
|
||||
type trial struct { |
||||
n int |
||||
percentFill float64 |
||||
ntrial int |
||||
|
||||
// only in the union test
|
||||
// only subtract test
|
||||
percentDelete float64 |
||||
|
||||
// only in 067 randomized operations
|
||||
// we do this + 1 passes
|
||||
numRandomOpsPass int |
||||
|
||||
// allow sampling range control
|
||||
// only recent tests respect this.
|
||||
srang *interval16 |
||||
} |
||||
|
||||
// And finds the intersection of rc and b.
|
||||
func (rc *runContainer16) And(b *Bitmap) *Bitmap { |
||||
out := NewBitmap() |
||||
for _, p := range rc.iv { |
||||
plast := p.last() |
||||
for i := p.start; i <= plast; i++ { |
||||
if b.Contains(uint32(i)) { |
||||
out.Add(uint32(i)) |
||||
} |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Xor returns the exclusive-or of rc and b.
|
||||
func (rc *runContainer16) Xor(b *Bitmap) *Bitmap { |
||||
out := b.Clone() |
||||
for _, p := range rc.iv { |
||||
plast := p.last() |
||||
for v := p.start; v <= plast; v++ { |
||||
w := uint32(v) |
||||
if out.Contains(w) { |
||||
out.RemoveRange(uint64(w), uint64(w+1)) |
||||
} else { |
||||
out.Add(w) |
||||
} |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
// Or returns the union of rc and b.
|
||||
func (rc *runContainer16) Or(b *Bitmap) *Bitmap { |
||||
out := b.Clone() |
||||
for _, p := range rc.iv { |
||||
plast := p.last() |
||||
for v := p.start; v <= plast; v++ { |
||||
out.Add(uint32(v)) |
||||
} |
||||
} |
||||
return out |
||||
} |
||||
|
||||
//func (rc *runContainer32) and(container) container {
|
||||
// panic("TODO. not yet implemented")
|
||||
//}
|
||||
|
||||
// serializedSizeInBytes returns the number of bytes of memory
|
||||
// required by this runContainer16. This is for the
|
||||
// Roaring format, as specified https://github.com/RoaringBitmap/RoaringFormatSpec/
|
||||
func (rc *runContainer16) serializedSizeInBytes() int { |
||||
// number of runs in one uint16, then each run
|
||||
// needs two more uint16
|
||||
return 2 + len(rc.iv)*4 |
||||
} |
||||
|
||||
// serializedSizeInBytes returns the number of bytes of memory
|
||||
// required by this runContainer32.
|
||||
func (rc *runContainer32) serializedSizeInBytes() int { |
||||
return 4 + len(rc.iv)*8 |
||||
} |
@ -1,695 +0,0 @@ |
||||
package roaring |
||||
|
||||
///////////////////////////////////////////////////
|
||||
//
|
||||
// container interface methods for runContainer16
|
||||
//
|
||||
///////////////////////////////////////////////////
|
||||
|
||||
import ( |
||||
"fmt" |
||||
) |
||||
|
||||
// compile time verify we meet interface requirements
|
||||
var _ container = &runContainer16{} |
||||
|
||||
func (rc *runContainer16) clone() container { |
||||
return newRunContainer16CopyIv(rc.iv) |
||||
} |
||||
|
||||
func (rc *runContainer16) minimum() uint16 { |
||||
return rc.iv[0].start // assume not empty
|
||||
} |
||||
|
||||
func (rc *runContainer16) maximum() uint16 { |
||||
return rc.iv[len(rc.iv)-1].last() // assume not empty
|
||||
} |
||||
|
||||
func (rc *runContainer16) isFull() bool { |
||||
return (len(rc.iv) == 1) && ((rc.iv[0].start == 0) && (rc.iv[0].last() == MaxUint16)) |
||||
} |
||||
|
||||
func (rc *runContainer16) and(a container) container { |
||||
if rc.isFull() { |
||||
return a.clone() |
||||
} |
||||
switch c := a.(type) { |
||||
case *runContainer16: |
||||
return rc.intersect(c) |
||||
case *arrayContainer: |
||||
return rc.andArray(c) |
||||
case *bitmapContainer: |
||||
return rc.andBitmapContainer(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
func (rc *runContainer16) andCardinality(a container) int { |
||||
switch c := a.(type) { |
||||
case *runContainer16: |
||||
return int(rc.intersectCardinality(c)) |
||||
case *arrayContainer: |
||||
return rc.andArrayCardinality(c) |
||||
case *bitmapContainer: |
||||
return rc.andBitmapContainerCardinality(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
// andBitmapContainer finds the intersection of rc and b.
|
||||
func (rc *runContainer16) andBitmapContainer(bc *bitmapContainer) container { |
||||
bc2 := newBitmapContainerFromRun(rc) |
||||
return bc2.andBitmap(bc) |
||||
} |
||||
|
||||
func (rc *runContainer16) andArrayCardinality(ac *arrayContainer) int { |
||||
pos := 0 |
||||
answer := 0 |
||||
maxpos := ac.getCardinality() |
||||
if maxpos == 0 { |
||||
return 0 // won't happen in actual code
|
||||
} |
||||
v := ac.content[pos] |
||||
mainloop: |
||||
for _, p := range rc.iv { |
||||
for v < p.start { |
||||
pos++ |
||||
if pos == maxpos { |
||||
break mainloop |
||||
} |
||||
v = ac.content[pos] |
||||
} |
||||
for v <= p.last() { |
||||
answer++ |
||||
pos++ |
||||
if pos == maxpos { |
||||
break mainloop |
||||
} |
||||
v = ac.content[pos] |
||||
} |
||||
} |
||||
return answer |
||||
} |
||||
|
||||
func (rc *runContainer16) iand(a container) container { |
||||
if rc.isFull() { |
||||
return a.clone() |
||||
} |
||||
switch c := a.(type) { |
||||
case *runContainer16: |
||||
return rc.inplaceIntersect(c) |
||||
case *arrayContainer: |
||||
return rc.andArray(c) |
||||
case *bitmapContainer: |
||||
return rc.iandBitmapContainer(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
func (rc *runContainer16) inplaceIntersect(rc2 *runContainer16) container { |
||||
// TODO: optimize by doing less allocation, possibly?
|
||||
|
||||
// sect will be new
|
||||
sect := rc.intersect(rc2) |
||||
*rc = *sect |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iandBitmapContainer(bc *bitmapContainer) container { |
||||
isect := rc.andBitmapContainer(bc) |
||||
*rc = *newRunContainer16FromContainer(isect) |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) andArray(ac *arrayContainer) container { |
||||
if len(rc.iv) == 0 { |
||||
return newArrayContainer() |
||||
} |
||||
|
||||
acCardinality := ac.getCardinality() |
||||
c := newArrayContainerCapacity(acCardinality) |
||||
|
||||
for rlePos, arrayPos := 0, 0; arrayPos < acCardinality; { |
||||
iv := rc.iv[rlePos] |
||||
arrayVal := ac.content[arrayPos] |
||||
|
||||
for iv.last() < arrayVal { |
||||
rlePos++ |
||||
if rlePos == len(rc.iv) { |
||||
return c |
||||
} |
||||
iv = rc.iv[rlePos] |
||||
} |
||||
|
||||
if iv.start > arrayVal { |
||||
arrayPos = advanceUntil(ac.content, arrayPos, len(ac.content), iv.start) |
||||
} else { |
||||
c.content = append(c.content, arrayVal) |
||||
arrayPos++ |
||||
} |
||||
} |
||||
return c |
||||
} |
||||
|
||||
func (rc *runContainer16) andNot(a container) container { |
||||
switch c := a.(type) { |
||||
case *arrayContainer: |
||||
return rc.andNotArray(c) |
||||
case *bitmapContainer: |
||||
return rc.andNotBitmap(c) |
||||
case *runContainer16: |
||||
return rc.andNotRunContainer16(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
func (rc *runContainer16) fillLeastSignificant16bits(x []uint32, i int, mask uint32) { |
||||
k := 0 |
||||
var val int64 |
||||
for _, p := range rc.iv { |
||||
n := p.runlen() |
||||
for j := int64(0); j < n; j++ { |
||||
val = int64(p.start) + j |
||||
x[k+i] = uint32(val) | mask |
||||
k++ |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (rc *runContainer16) getShortIterator() shortIterable { |
||||
return rc.newRunIterator16() |
||||
} |
||||
|
||||
func (rc *runContainer16) getManyIterator() manyIterable { |
||||
return rc.newManyRunIterator16() |
||||
} |
||||
|
||||
// add the values in the range [firstOfRange, endx). endx
|
||||
// is still abe to express 2^16 because it is an int not an uint16.
|
||||
func (rc *runContainer16) iaddRange(firstOfRange, endx int) container { |
||||
|
||||
if firstOfRange >= endx { |
||||
panic(fmt.Sprintf("invalid %v = endx >= firstOfRange", endx)) |
||||
} |
||||
addme := newRunContainer16TakeOwnership([]interval16{ |
||||
{ |
||||
start: uint16(firstOfRange), |
||||
length: uint16(endx - 1 - firstOfRange), |
||||
}, |
||||
}) |
||||
*rc = *rc.union(addme) |
||||
return rc |
||||
} |
||||
|
||||
// remove the values in the range [firstOfRange,endx)
|
||||
func (rc *runContainer16) iremoveRange(firstOfRange, endx int) container { |
||||
if firstOfRange >= endx { |
||||
panic(fmt.Sprintf("request to iremove empty set [%v, %v),"+ |
||||
" nothing to do.", firstOfRange, endx)) |
||||
//return rc
|
||||
} |
||||
x := newInterval16Range(uint16(firstOfRange), uint16(endx-1)) |
||||
rc.isubtract(x) |
||||
return rc |
||||
} |
||||
|
||||
// not flip the values in the range [firstOfRange,endx)
|
||||
func (rc *runContainer16) not(firstOfRange, endx int) container { |
||||
if firstOfRange >= endx { |
||||
panic(fmt.Sprintf("invalid %v = endx >= firstOfRange = %v", endx, firstOfRange)) |
||||
} |
||||
|
||||
return rc.Not(firstOfRange, endx) |
||||
} |
||||
|
||||
// Not flips the values in the range [firstOfRange,endx).
|
||||
// This is not inplace. Only the returned value has the flipped bits.
|
||||
//
|
||||
// Currently implemented as (!A intersect B) union (A minus B),
|
||||
// where A is rc, and B is the supplied [firstOfRange, endx) interval.
|
||||
//
|
||||
// TODO(time optimization): convert this to a single pass
|
||||
// algorithm by copying AndNotRunContainer16() and modifying it.
|
||||
// Current routine is correct but
|
||||
// makes 2 more passes through the arrays than should be
|
||||
// strictly necessary. Measure both ways though--this may not matter.
|
||||
//
|
||||
func (rc *runContainer16) Not(firstOfRange, endx int) *runContainer16 { |
||||
|
||||
if firstOfRange >= endx { |
||||
panic(fmt.Sprintf("invalid %v = endx >= firstOfRange == %v", endx, firstOfRange)) |
||||
} |
||||
|
||||
if firstOfRange >= endx { |
||||
return rc.Clone() |
||||
} |
||||
|
||||
a := rc |
||||
// algo:
|
||||
// (!A intersect B) union (A minus B)
|
||||
|
||||
nota := a.invert() |
||||
|
||||
bs := []interval16{newInterval16Range(uint16(firstOfRange), uint16(endx-1))} |
||||
b := newRunContainer16TakeOwnership(bs) |
||||
|
||||
notAintersectB := nota.intersect(b) |
||||
|
||||
aMinusB := a.AndNotRunContainer16(b) |
||||
|
||||
rc2 := notAintersectB.union(aMinusB) |
||||
return rc2 |
||||
} |
||||
|
||||
// equals is now logical equals; it does not require the
|
||||
// same underlying container type.
|
||||
func (rc *runContainer16) equals(o container) bool { |
||||
srb, ok := o.(*runContainer16) |
||||
|
||||
if !ok { |
||||
// maybe value instead of pointer
|
||||
val, valok := o.(*runContainer16) |
||||
if valok { |
||||
srb = val |
||||
ok = true |
||||
} |
||||
} |
||||
if ok { |
||||
// Check if the containers are the same object.
|
||||
if rc == srb { |
||||
return true |
||||
} |
||||
|
||||
if len(srb.iv) != len(rc.iv) { |
||||
return false |
||||
} |
||||
|
||||
for i, v := range rc.iv { |
||||
if v != srb.iv[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// use generic comparison
|
||||
if o.getCardinality() != rc.getCardinality() { |
||||
return false |
||||
} |
||||
rit := rc.getShortIterator() |
||||
bit := o.getShortIterator() |
||||
|
||||
//k := 0
|
||||
for rit.hasNext() { |
||||
if bit.next() != rit.next() { |
||||
return false |
||||
} |
||||
//k++
|
||||
} |
||||
return true |
||||
} |
||||
|
||||
func (rc *runContainer16) iaddReturnMinimized(x uint16) container { |
||||
rc.Add(x) |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iadd(x uint16) (wasNew bool) { |
||||
return rc.Add(x) |
||||
} |
||||
|
||||
func (rc *runContainer16) iremoveReturnMinimized(x uint16) container { |
||||
rc.removeKey(x) |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iremove(x uint16) bool { |
||||
return rc.removeKey(x) |
||||
} |
||||
|
||||
func (rc *runContainer16) or(a container) container { |
||||
if rc.isFull() { |
||||
return rc.clone() |
||||
} |
||||
switch c := a.(type) { |
||||
case *runContainer16: |
||||
return rc.union(c) |
||||
case *arrayContainer: |
||||
return rc.orArray(c) |
||||
case *bitmapContainer: |
||||
return rc.orBitmapContainer(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
func (rc *runContainer16) orCardinality(a container) int { |
||||
switch c := a.(type) { |
||||
case *runContainer16: |
||||
return int(rc.unionCardinality(c)) |
||||
case *arrayContainer: |
||||
return rc.orArrayCardinality(c) |
||||
case *bitmapContainer: |
||||
return rc.orBitmapContainerCardinality(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
// orBitmapContainer finds the union of rc and bc.
|
||||
func (rc *runContainer16) orBitmapContainer(bc *bitmapContainer) container { |
||||
bc2 := newBitmapContainerFromRun(rc) |
||||
return bc2.iorBitmap(bc) |
||||
} |
||||
|
||||
func (rc *runContainer16) andBitmapContainerCardinality(bc *bitmapContainer) int { |
||||
answer := 0 |
||||
for i := range rc.iv { |
||||
answer += bc.getCardinalityInRange(uint(rc.iv[i].start), uint(rc.iv[i].last())+1) |
||||
} |
||||
//bc.computeCardinality()
|
||||
return answer |
||||
} |
||||
|
||||
func (rc *runContainer16) orBitmapContainerCardinality(bc *bitmapContainer) int { |
||||
return rc.getCardinality() + bc.getCardinality() - rc.andBitmapContainerCardinality(bc) |
||||
} |
||||
|
||||
// orArray finds the union of rc and ac.
|
||||
func (rc *runContainer16) orArray(ac *arrayContainer) container { |
||||
bc1 := newBitmapContainerFromRun(rc) |
||||
bc2 := ac.toBitmapContainer() |
||||
return bc1.orBitmap(bc2) |
||||
} |
||||
|
||||
// orArray finds the union of rc and ac.
|
||||
func (rc *runContainer16) orArrayCardinality(ac *arrayContainer) int { |
||||
return ac.getCardinality() + rc.getCardinality() - rc.andArrayCardinality(ac) |
||||
} |
||||
|
||||
func (rc *runContainer16) ior(a container) container { |
||||
if rc.isFull() { |
||||
return rc |
||||
} |
||||
switch c := a.(type) { |
||||
case *runContainer16: |
||||
return rc.inplaceUnion(c) |
||||
case *arrayContainer: |
||||
return rc.iorArray(c) |
||||
case *bitmapContainer: |
||||
return rc.iorBitmapContainer(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
func (rc *runContainer16) inplaceUnion(rc2 *runContainer16) container { |
||||
p("rc.inplaceUnion with len(rc2.iv)=%v", len(rc2.iv)) |
||||
for _, p := range rc2.iv { |
||||
last := int64(p.last()) |
||||
for i := int64(p.start); i <= last; i++ { |
||||
rc.Add(uint16(i)) |
||||
} |
||||
} |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iorBitmapContainer(bc *bitmapContainer) container { |
||||
|
||||
it := bc.getShortIterator() |
||||
for it.hasNext() { |
||||
rc.Add(it.next()) |
||||
} |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iorArray(ac *arrayContainer) container { |
||||
it := ac.getShortIterator() |
||||
for it.hasNext() { |
||||
rc.Add(it.next()) |
||||
} |
||||
return rc |
||||
} |
||||
|
||||
// lazyIOR is described (not yet implemented) in
|
||||
// this nice note from @lemire on
|
||||
// https://github.com/RoaringBitmap/roaring/pull/70#issuecomment-263613737
|
||||
//
|
||||
// Description of lazyOR and lazyIOR from @lemire:
|
||||
//
|
||||
// Lazy functions are optional and can be simply
|
||||
// wrapper around non-lazy functions.
|
||||
//
|
||||
// The idea of "laziness" is as follows. It is
|
||||
// inspired by the concept of lazy evaluation
|
||||
// you might be familiar with (functional programming
|
||||
// and all that). So a roaring bitmap is
|
||||
// such that all its containers are, in some
|
||||
// sense, chosen to use as little memory as
|
||||
// possible. This is nice. Also, all bitsets
|
||||
// are "cardinality aware" so that you can do
|
||||
// fast rank/select queries, or query the
|
||||
// cardinality of the whole bitmap... very fast,
|
||||
// without latency.
|
||||
//
|
||||
// However, imagine that you are aggregating 100
|
||||
// bitmaps together. So you OR the first two, then OR
|
||||
// that with the third one and so forth. Clearly,
|
||||
// intermediate bitmaps don't need to be as
|
||||
// compressed as possible, right? They can be
|
||||
// in a "dirty state". You only need the end
|
||||
// result to be in a nice state... which you
|
||||
// can achieve by calling repairAfterLazy at the end.
|
||||
//
|
||||
// The Java/C code does something special for
|
||||
// the in-place lazy OR runs. The idea is that
|
||||
// instead of taking two run containers and
|
||||
// generating a new one, we actually try to
|
||||
// do the computation in-place through a
|
||||
// technique invented by @gssiyankai (pinging him!).
|
||||
// What you do is you check whether the host
|
||||
// run container has lots of extra capacity.
|
||||
// If it does, you move its data at the end of
|
||||
// the backing array, and then you write
|
||||
// the answer at the beginning. What this
|
||||
// trick does is minimize memory allocations.
|
||||
//
|
||||
func (rc *runContainer16) lazyIOR(a container) container { |
||||
// not lazy at the moment
|
||||
// TODO: make it lazy
|
||||
return rc.ior(a) |
||||
|
||||
/* |
||||
switch c := a.(type) { |
||||
case *arrayContainer: |
||||
return rc.lazyIorArray(c) |
||||
case *bitmapContainer: |
||||
return rc.lazyIorBitmap(c) |
||||
case *runContainer16: |
||||
return rc.lazyIorRun16(c) |
||||
} |
||||
panic("unsupported container type") |
||||
*/ |
||||
} |
||||
|
||||
// lazyOR is described above in lazyIOR.
|
||||
func (rc *runContainer16) lazyOR(a container) container { |
||||
|
||||
// not lazy at the moment
|
||||
// TODO: make it lazy
|
||||
return rc.or(a) |
||||
|
||||
/* |
||||
switch c := a.(type) { |
||||
case *arrayContainer: |
||||
return rc.lazyOrArray(c) |
||||
case *bitmapContainer: |
||||
return rc.lazyOrBitmap(c) |
||||
case *runContainer16: |
||||
return rc.lazyOrRunContainer16(c) |
||||
} |
||||
panic("unsupported container type") |
||||
*/ |
||||
} |
||||
|
||||
func (rc *runContainer16) intersects(a container) bool { |
||||
// TODO: optimize by doing inplace/less allocation, possibly?
|
||||
isect := rc.and(a) |
||||
return isect.getCardinality() > 0 |
||||
} |
||||
|
||||
func (rc *runContainer16) xor(a container) container { |
||||
switch c := a.(type) { |
||||
case *arrayContainer: |
||||
return rc.xorArray(c) |
||||
case *bitmapContainer: |
||||
return rc.xorBitmap(c) |
||||
case *runContainer16: |
||||
return rc.xorRunContainer16(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
func (rc *runContainer16) iandNot(a container) container { |
||||
switch c := a.(type) { |
||||
case *arrayContainer: |
||||
return rc.iandNotArray(c) |
||||
case *bitmapContainer: |
||||
return rc.iandNotBitmap(c) |
||||
case *runContainer16: |
||||
return rc.iandNotRunContainer16(c) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
||||
|
||||
// flip the values in the range [firstOfRange,endx)
|
||||
func (rc *runContainer16) inot(firstOfRange, endx int) container { |
||||
if firstOfRange >= endx { |
||||
panic(fmt.Sprintf("invalid %v = endx >= firstOfRange = %v", endx, firstOfRange)) |
||||
} |
||||
// TODO: minimize copies, do it all inplace; not() makes a copy.
|
||||
rc = rc.Not(firstOfRange, endx) |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) getCardinality() int { |
||||
return int(rc.cardinality()) |
||||
} |
||||
|
||||
func (rc *runContainer16) rank(x uint16) int { |
||||
n := int64(len(rc.iv)) |
||||
xx := int64(x) |
||||
w, already, _ := rc.search(xx, nil) |
||||
if w < 0 { |
||||
return 0 |
||||
} |
||||
if !already && w == n-1 { |
||||
return rc.getCardinality() |
||||
} |
||||
var rnk int64 |
||||
if !already { |
||||
for i := int64(0); i <= w; i++ { |
||||
rnk += rc.iv[i].runlen() |
||||
} |
||||
return int(rnk) |
||||
} |
||||
for i := int64(0); i < w; i++ { |
||||
rnk += rc.iv[i].runlen() |
||||
} |
||||
rnk += int64(x-rc.iv[w].start) + 1 |
||||
return int(rnk) |
||||
} |
||||
|
||||
func (rc *runContainer16) selectInt(x uint16) int { |
||||
return rc.selectInt16(x) |
||||
} |
||||
|
||||
func (rc *runContainer16) andNotRunContainer16(b *runContainer16) container { |
||||
return rc.AndNotRunContainer16(b) |
||||
} |
||||
|
||||
func (rc *runContainer16) andNotArray(ac *arrayContainer) container { |
||||
rcb := rc.toBitmapContainer() |
||||
acb := ac.toBitmapContainer() |
||||
return rcb.andNotBitmap(acb) |
||||
} |
||||
|
||||
func (rc *runContainer16) andNotBitmap(bc *bitmapContainer) container { |
||||
rcb := rc.toBitmapContainer() |
||||
return rcb.andNotBitmap(bc) |
||||
} |
||||
|
||||
func (rc *runContainer16) toBitmapContainer() *bitmapContainer { |
||||
p("run16 toBitmap starting; rc has %v ranges", len(rc.iv)) |
||||
bc := newBitmapContainer() |
||||
for i := range rc.iv { |
||||
bc.iaddRange(int(rc.iv[i].start), int(rc.iv[i].last())+1) |
||||
} |
||||
bc.computeCardinality() |
||||
return bc |
||||
} |
||||
|
||||
func (rc *runContainer16) iandNotRunContainer16(x2 *runContainer16) container { |
||||
rcb := rc.toBitmapContainer() |
||||
x2b := x2.toBitmapContainer() |
||||
rcb.iandNotBitmapSurely(x2b) |
||||
// TODO: check size and optimize the return value
|
||||
// TODO: is inplace modification really required? If not, elide the copy.
|
||||
rc2 := newRunContainer16FromBitmapContainer(rcb) |
||||
*rc = *rc2 |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iandNotArray(ac *arrayContainer) container { |
||||
rcb := rc.toBitmapContainer() |
||||
acb := ac.toBitmapContainer() |
||||
rcb.iandNotBitmapSurely(acb) |
||||
// TODO: check size and optimize the return value
|
||||
// TODO: is inplace modification really required? If not, elide the copy.
|
||||
rc2 := newRunContainer16FromBitmapContainer(rcb) |
||||
*rc = *rc2 |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) iandNotBitmap(bc *bitmapContainer) container { |
||||
rcb := rc.toBitmapContainer() |
||||
rcb.iandNotBitmapSurely(bc) |
||||
// TODO: check size and optimize the return value
|
||||
// TODO: is inplace modification really required? If not, elide the copy.
|
||||
rc2 := newRunContainer16FromBitmapContainer(rcb) |
||||
*rc = *rc2 |
||||
return rc |
||||
} |
||||
|
||||
func (rc *runContainer16) xorRunContainer16(x2 *runContainer16) container { |
||||
rcb := rc.toBitmapContainer() |
||||
x2b := x2.toBitmapContainer() |
||||
return rcb.xorBitmap(x2b) |
||||
} |
||||
|
||||
func (rc *runContainer16) xorArray(ac *arrayContainer) container { |
||||
rcb := rc.toBitmapContainer() |
||||
acb := ac.toBitmapContainer() |
||||
return rcb.xorBitmap(acb) |
||||
} |
||||
|
||||
func (rc *runContainer16) xorBitmap(bc *bitmapContainer) container { |
||||
rcb := rc.toBitmapContainer() |
||||
return rcb.xorBitmap(bc) |
||||
} |
||||
|
||||
// convert to bitmap or array *if needed*
|
||||
func (rc *runContainer16) toEfficientContainer() container { |
||||
|
||||
// runContainer16SerializedSizeInBytes(numRuns)
|
||||
sizeAsRunContainer := rc.getSizeInBytes() |
||||
sizeAsBitmapContainer := bitmapContainerSizeInBytes() |
||||
card := int(rc.cardinality()) |
||||
sizeAsArrayContainer := arrayContainerSizeInBytes(card) |
||||
if sizeAsRunContainer <= minOfInt(sizeAsBitmapContainer, sizeAsArrayContainer) { |
||||
return rc |
||||
} |
||||
if card <= arrayDefaultMaxSize { |
||||
return rc.toArrayContainer() |
||||
} |
||||
bc := newBitmapContainerFromRun(rc) |
||||
return bc |
||||
} |
||||
|
||||
func (rc *runContainer16) toArrayContainer() *arrayContainer { |
||||
ac := newArrayContainer() |
||||
for i := range rc.iv { |
||||
ac.iaddRange(int(rc.iv[i].start), int(rc.iv[i].last())+1) |
||||
} |
||||
return ac |
||||
} |
||||
|
||||
func newRunContainer16FromContainer(c container) *runContainer16 { |
||||
|
||||
switch x := c.(type) { |
||||
case *runContainer16: |
||||
return x.Clone() |
||||
case *arrayContainer: |
||||
return newRunContainer16FromArray(x) |
||||
case *bitmapContainer: |
||||
return newRunContainer16FromBitmapContainer(x) |
||||
} |
||||
panic("unsupported container type") |
||||
} |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,94 @@ |
||||
// Copyright (c) 2019 Couchbase, Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package query |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"fmt" |
||||
|
||||
"github.com/blevesearch/bleve/geo" |
||||
"github.com/blevesearch/bleve/index" |
||||
"github.com/blevesearch/bleve/mapping" |
||||
"github.com/blevesearch/bleve/search" |
||||
"github.com/blevesearch/bleve/search/searcher" |
||||
) |
||||
|
||||
type GeoBoundingPolygonQuery struct { |
||||
Points []geo.Point `json:"polygon_points"` |
||||
FieldVal string `json:"field,omitempty"` |
||||
BoostVal *Boost `json:"boost,omitempty"` |
||||
} |
||||
|
||||
func NewGeoBoundingPolygonQuery(points []geo.Point) *GeoBoundingPolygonQuery { |
||||
return &GeoBoundingPolygonQuery{ |
||||
Points: points} |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) SetBoost(b float64) { |
||||
boost := Boost(b) |
||||
q.BoostVal = &boost |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) Boost() float64 { |
||||
return q.BoostVal.Value() |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) SetField(f string) { |
||||
q.FieldVal = f |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) Field() string { |
||||
return q.FieldVal |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) Searcher(i index.IndexReader, |
||||
m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) { |
||||
field := q.FieldVal |
||||
if q.FieldVal == "" { |
||||
field = m.DefaultSearchField() |
||||
} |
||||
|
||||
return searcher.NewGeoBoundedPolygonSearcher(i, q.Points, field, q.BoostVal.Value(), options) |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) Validate() error { |
||||
return nil |
||||
} |
||||
|
||||
func (q *GeoBoundingPolygonQuery) UnmarshalJSON(data []byte) error { |
||||
tmp := struct { |
||||
Points []interface{} `json:"polygon_points"` |
||||
FieldVal string `json:"field,omitempty"` |
||||
BoostVal *Boost `json:"boost,omitempty"` |
||||
}{} |
||||
err := json.Unmarshal(data, &tmp) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
q.Points = make([]geo.Point, 0, len(tmp.Points)) |
||||
for _, i := range tmp.Points { |
||||
// now use our generic point parsing code from the geo package
|
||||
lon, lat, found := geo.ExtractGeoPoint(i) |
||||
if !found { |
||||
return fmt.Errorf("geo polygon point: %v is not in a valid format", i) |
||||
} |
||||
q.Points = append(q.Points, geo.Point{Lon: lon, Lat: lat}) |
||||
} |
||||
|
||||
q.FieldVal = tmp.FieldVal |
||||
q.BoostVal = tmp.BoostVal |
||||
return nil |
||||
} |
11
vendor/github.com/blevesearch/bleve/search/searcher/search_geopointdistance.go
generated
vendored
11
vendor/github.com/blevesearch/bleve/search/searcher/search_geopointdistance.go
generated
vendored
@ -0,0 +1,110 @@ |
||||
// Copyright (c) 2019 Couchbase, Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package searcher |
||||
|
||||
import ( |
||||
"github.com/blevesearch/bleve/geo" |
||||
"github.com/blevesearch/bleve/index" |
||||
"github.com/blevesearch/bleve/numeric" |
||||
"github.com/blevesearch/bleve/search" |
||||
"math" |
||||
) |
||||
|
||||
func NewGeoBoundedPolygonSearcher(indexReader index.IndexReader, |
||||
polygon []geo.Point, field string, boost float64, |
||||
options search.SearcherOptions) (search.Searcher, error) { |
||||
|
||||
// compute the bounding box enclosing the polygon
|
||||
topLeftLon, topLeftLat, bottomRightLon, bottomRightLat, err := |
||||
geo.BoundingRectangleForPolygon(polygon) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// build a searcher for the bounding box on the polygon
|
||||
boxSearcher, err := boxSearcher(indexReader, |
||||
topLeftLon, topLeftLat, bottomRightLon, bottomRightLat, |
||||
field, boost, options, true) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
dvReader, err := indexReader.DocValueReader([]string{field}) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// wrap it in a filtering searcher that checks for the polygon inclusivity
|
||||
return NewFilteringSearcher(boxSearcher, |
||||
buildPolygonFilter(dvReader, field, polygon)), nil |
||||
} |
||||
|
||||
const float64EqualityThreshold = 1e-6 |
||||
|
||||
func almostEqual(a, b float64) bool { |
||||
return math.Abs(a-b) <= float64EqualityThreshold |
||||
} |
||||
|
||||
// buildPolygonFilter returns true if the point lies inside the
|
||||
// polygon. It is based on the ray-casting technique as referred
|
||||
// here: https://wrf.ecse.rpi.edu/nikola/pubdetails/pnpoly.html
|
||||
func buildPolygonFilter(dvReader index.DocValueReader, field string, |
||||
polygon []geo.Point) FilterFunc { |
||||
return func(d *search.DocumentMatch) bool { |
||||
var lon, lat float64 |
||||
var found bool |
||||
|
||||
err := dvReader.VisitDocValues(d.IndexInternalID, func(field string, term []byte) { |
||||
// only consider the values which are shifted 0
|
||||
prefixCoded := numeric.PrefixCoded(term) |
||||
shift, err := prefixCoded.Shift() |
||||
if err == nil && shift == 0 { |
||||
i64, err := prefixCoded.Int64() |
||||
if err == nil { |
||||
lon = geo.MortonUnhashLon(uint64(i64)) |
||||
lat = geo.MortonUnhashLat(uint64(i64)) |
||||
found = true |
||||
} |
||||
} |
||||
}) |
||||
|
||||
// Note: this approach works for points which are strictly inside
|
||||
// the polygon. ie it might fail for certain points on the polygon boundaries.
|
||||
if err == nil && found { |
||||
nVertices := len(polygon) |
||||
var inside bool |
||||
// check for a direct vertex match
|
||||
if almostEqual(polygon[0].Lat, lat) && |
||||
almostEqual(polygon[0].Lon, lon) { |
||||
return true |
||||
} |
||||
|
||||
for i := 1; i < nVertices; i++ { |
||||
if almostEqual(polygon[i].Lat, lat) && |
||||
almostEqual(polygon[i].Lon, lon) { |
||||
return true |
||||
} |
||||
if (polygon[i].Lat > lat) != (polygon[i-1].Lat > lat) && |
||||
lon < (polygon[i-1].Lon-polygon[i].Lon)*(lat-polygon[i].Lat)/ |
||||
(polygon[i-1].Lat-polygon[i].Lat)+polygon[i].Lon { |
||||
inside = !inside |
||||
} |
||||
} |
||||
return inside |
||||
|
||||
} |
||||
return false |
||||
} |
||||
} |
@ -0,0 +1,10 @@ |
||||
module github.com/couchbase/vellum |
||||
|
||||
go 1.12 |
||||
|
||||
require ( |
||||
github.com/edsrzf/mmap-go v1.0.0 |
||||
github.com/spf13/cobra v0.0.5 |
||||
github.com/willf/bitset v1.1.10 |
||||
golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a // indirect |
||||
) |
@ -0,0 +1,39 @@ |
||||
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= |
||||
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= |
||||
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= |
||||
github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= |
||||
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= |
||||
github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= |
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||
github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw= |
||||
github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= |
||||
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= |
||||
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= |
||||
github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= |
||||
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= |
||||
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= |
||||
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= |
||||
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= |
||||
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= |
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= |
||||
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= |
||||
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= |
||||
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= |
||||
github.com/spf13/cobra v0.0.5 h1:f0B+LkLX6DtmRH1isoNA9VTtNUK9K8xYd28JNNfOv/s= |
||||
github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= |
||||
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= |
||||
github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg= |
||||
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= |
||||
github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= |
||||
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= |
||||
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= |
||||
github.com/willf/bitset v1.1.10 h1:NotGKqX0KwQ72NUzqrjZq5ipPNDQex9lo3WpaS8L2sc= |
||||
github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= |
||||
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= |
||||
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= |
||||
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= |
||||
golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a h1:aYOabOQFp6Vj6W1F80affTUvO9UxmJRx8K0gsfABByQ= |
||||
golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= |
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= |
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= |
||||
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= |
@ -0,0 +1,12 @@ |
||||
// +build riscv64
|
||||
|
||||
package bbolt |
||||
|
||||
// maxMapSize represents the largest mmap size supported by Bolt.
|
||||
const maxMapSize = 0xFFFFFFFFFFFF // 256TB
|
||||
|
||||
// maxAllocSize is the size used when creating array pointers.
|
||||
const maxAllocSize = 0x7FFFFFFF |
||||
|
||||
// Are unaligned load/stores broken on this arch?
|
||||
var brokenUnaligned = true |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue