Switch from Godep to go vendoring

vendor/github.com/blevesearch/bleve/numeric_util/float.go

@@ -0,0 +1,29 @@
+//  Copyright (c) 2014 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 numeric_util
+
+import (
+	"math"
+)
+
+func Float64ToInt64(f float64) int64 {
+	fasint := int64(math.Float64bits(f))
+	if fasint < 0 {
+		fasint = fasint ^ 0x7fffffffffffffff
+	}
+	return fasint
+}
+
+func Int64ToFloat64(i int64) float64 {
+	if i < 0 {
+		i ^= 0x7fffffffffffffff
+	}
+	return math.Float64frombits(uint64(i))
+}

vendor/github.com/blevesearch/bleve/numeric_util/float_test.go

@@ -0,0 +1,59 @@
+//  Copyright (c) 2014 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 numeric_util
+
+import (
+	"testing"
+)
+
+// test that the float/sortable int operations work both ways
+// and that the corresponding integers sort the same as
+// the original floats would have
+func TestSortabledFloat64ToInt64(t *testing.T) {
+	tests := []struct {
+		input float64
+	}{
+		{
+			input: -4640094584139352638,
+		},
+		{
+			input: -167.42,
+		},
+		{
+			input: -1.11,
+		},
+		{
+			input: 0,
+		},
+		{
+			input: 3.14,
+		},
+		{
+			input: 167.42,
+		},
+	}
+
+	var lastInt64 *int64
+	for _, test := range tests {
+		actual := Float64ToInt64(test.input)
+		if lastInt64 != nil {
+			// check that this float is greater than the last one
+			if actual <= *lastInt64 {
+				t.Errorf("expected greater than prev, this: %d, last %d", actual, *lastInt64)
+			}
+		}
+		lastInt64 = &actual
+		convertedBack := Int64ToFloat64(actual)
+		// assert that we got back what we started with
+		if convertedBack != test.input {
+			t.Errorf("expected %f, got %f", test.input, convertedBack)
+		}
+	}
+}

vendor/github.com/blevesearch/bleve/numeric_util/prefix_coded.go

@@ -0,0 +1,74 @@
+//  Copyright (c) 2014 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 numeric_util
+
+import (
+	"fmt"
+)
+
+const ShiftStartInt64 byte = 0x20
+
+// PrefixCoded is a byte array encoding of
+// 64-bit numeric values shifted by 0-63 bits
+type PrefixCoded []byte
+
+func NewPrefixCodedInt64(in int64, shift uint) (PrefixCoded, error) {
+	if shift > 63 {
+		return nil, fmt.Errorf("cannot shift %d, must be between 0 and 63", shift)
+	}
+
+	nChars := (((63 - shift) * 37) >> 8) + 1
+	rv := make(PrefixCoded, nChars+1)
+	rv[0] = ShiftStartInt64 + byte(shift)
+
+	sortableBits := int64(uint64(in) ^ 0x8000000000000000)
+	sortableBits = int64(uint64(sortableBits) >> shift)
+	for nChars > 0 {
+		// Store 7 bits per byte for compatibility
+		// with UTF-8 encoding of terms
+		rv[nChars] = byte(sortableBits & 0x7f)
+		nChars--
+		sortableBits = int64(uint64(sortableBits) >> 7)
+	}
+	return rv, nil
+}
+
+func MustNewPrefixCodedInt64(in int64, shift uint) PrefixCoded {
+	rv, err := NewPrefixCodedInt64(in, shift)
+	if err != nil {
+		panic(err)
+	}
+	return rv
+}
+
+// Shift returns the number of bits shifted
+// returns 0 if in uninitialized state
+func (p PrefixCoded) Shift() (uint, error) {
+	if len(p) > 0 {
+		shift := p[0] - ShiftStartInt64
+		if shift < 0 || shift < 63 {
+			return uint(shift), nil
+		}
+	}
+	return 0, fmt.Errorf("invalid prefix coded value")
+}
+
+func (p PrefixCoded) Int64() (int64, error) {
+	shift, err := p.Shift()
+	if err != nil {
+		return 0, err
+	}
+	var sortableBits int64
+	for _, inbyte := range p[1:] {
+		sortableBits <<= 7
+		sortableBits |= int64(inbyte)
+	}
+	return int64(uint64((sortableBits << shift)) ^ 0x8000000000000000), nil
+}

vendor/github.com/blevesearch/bleve/numeric_util/prefix_coded_test.go

@@ -0,0 +1,98 @@
+//  Copyright (c) 2014 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 numeric_util
+
+import (
+	"reflect"
+	"testing"
+)
+
+// these array encoding values have been verified manually
+// against the lucene implementation
+func TestPrefixCoded(t *testing.T) {
+	tests := []struct {
+		input  int64
+		shift  uint
+		output PrefixCoded
+	}{
+		{
+			input:  1,
+			shift:  0,
+			output: PrefixCoded{0x20, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
+		},
+		{
+			input:  -1,
+			shift:  0,
+			output: PrefixCoded{0x20, 0x0, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f},
+		},
+		{
+			input:  -94582,
+			shift:  0,
+			output: PrefixCoded{0x20, 0x0, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7a, 0x1d, 0xa},
+		},
+		{
+			input:  314729851,
+			shift:  0,
+			output: PrefixCoded{0x20, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x16, 0x9, 0x4a, 0x7b},
+		},
+		{
+			input:  314729851,
+			shift:  4,
+			output: PrefixCoded{0x24, 0x8, 0x0, 0x0, 0x0, 0x0, 0x9, 0x30, 0x4c, 0x57},
+		},
+		{
+			input:  314729851,
+			shift:  8,
+			output: PrefixCoded{0x28, 0x40, 0x0, 0x0, 0x0, 0x0, 0x4b, 0x4, 0x65},
+		},
+		{
+			input:  314729851,
+			shift:  16,
+			output: PrefixCoded{0x30, 0x20, 0x0, 0x0, 0x0, 0x0, 0x25, 0x42},
+		},
+		{
+			input:  314729851,
+			shift:  32,
+			output: PrefixCoded{0x40, 0x8, 0x0, 0x0, 0x0, 0x0},
+		},
+		{
+			input:  1234729851,
+			shift:  32,
+			output: PrefixCoded{0x40, 0x8, 0x0, 0x0, 0x0, 0x0},
+		},
+	}
+
+	for _, test := range tests {
+		actual, err := NewPrefixCodedInt64(test.input, test.shift)
+		if err != nil {
+			t.Error(err)
+		}
+		if !reflect.DeepEqual(actual, test.output) {
+			t.Errorf("expected %#v, got %#v", test.output, actual)
+		}
+		checkedShift, err := actual.Shift()
+		if err != nil {
+			t.Error(err)
+		}
+		if checkedShift != test.shift {
+			t.Errorf("expected %d, got %d", test.shift, checkedShift)
+		}
+		// if the shift was 0, make sure we can go back to the original
+		if test.shift == 0 {
+			backToLong, err := actual.Int64()
+			if err != nil {
+				t.Error(err)
+			}
+			if backToLong != test.input {
+				t.Errorf("expected %v, got %v", test.input, backToLong)
+			}
+		}
+	}
+}