segment_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/m3ninx/index/segment/types.go

// Copyright (c) 2019 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

// Package segment is a generated GoMock package.
package segment

import (
	"reflect"

	"github.com/m3db/m3/src/m3ninx/doc"
	"github.com/m3db/m3/src/m3ninx/index"
	"github.com/m3db/m3/src/m3ninx/postings"

	"github.com/golang/mock/gomock"
)

// MockSegment is a mock of Segment interface
type MockSegment struct {
	ctrl     *gomock.Controller
	recorder *MockSegmentMockRecorder
}

// MockSegmentMockRecorder is the mock recorder for MockSegment
type MockSegmentMockRecorder struct {
	mock *MockSegment
}

// NewMockSegment creates a new mock instance
func NewMockSegment(ctrl *gomock.Controller) *MockSegment {
	mock := &MockSegment{ctrl: ctrl}
	mock.recorder = &MockSegmentMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSegment) EXPECT() *MockSegmentMockRecorder {
	return m.recorder
}

// FieldsIterable mocks base method
func (m *MockSegment) FieldsIterable() FieldsIterable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FieldsIterable")
	ret0, _ := ret[0].(FieldsIterable)
	return ret0
}

// FieldsIterable indicates an expected call of FieldsIterable
func (mr *MockSegmentMockRecorder) FieldsIterable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FieldsIterable", reflect.TypeOf((*MockSegment)(nil).FieldsIterable))
}

// TermsIterable mocks base method
func (m *MockSegment) TermsIterable() TermsIterable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TermsIterable")
	ret0, _ := ret[0].(TermsIterable)
	return ret0
}

// TermsIterable indicates an expected call of TermsIterable
func (mr *MockSegmentMockRecorder) TermsIterable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TermsIterable", reflect.TypeOf((*MockSegment)(nil).TermsIterable))
}

// Size mocks base method
func (m *MockSegment) Size() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int64)
	return ret0
}

// Size indicates an expected call of Size
func (mr *MockSegmentMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockSegment)(nil).Size))
}

// ContainsID mocks base method
func (m *MockSegment) ContainsID(docID []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainsID", docID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainsID indicates an expected call of ContainsID
func (mr *MockSegmentMockRecorder) ContainsID(docID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsID", reflect.TypeOf((*MockSegment)(nil).ContainsID), docID)
}

// ContainsField mocks base method
func (m *MockSegment) ContainsField(field []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainsField", field)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainsField indicates an expected call of ContainsField
func (mr *MockSegmentMockRecorder) ContainsField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsField", reflect.TypeOf((*MockSegment)(nil).ContainsField), field)
}

// Reader mocks base method
func (m *MockSegment) Reader() (index.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reader")
	ret0, _ := ret[0].(index.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Reader indicates an expected call of Reader
func (mr *MockSegmentMockRecorder) Reader() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reader", reflect.TypeOf((*MockSegment)(nil).Reader))
}

// Close mocks base method
func (m *MockSegment) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockSegmentMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSegment)(nil).Close))
}

// MockFieldsIterable is a mock of FieldsIterable interface
type MockFieldsIterable struct {
	ctrl     *gomock.Controller
	recorder *MockFieldsIterableMockRecorder
}

// MockFieldsIterableMockRecorder is the mock recorder for MockFieldsIterable
type MockFieldsIterableMockRecorder struct {
	mock *MockFieldsIterable
}

// NewMockFieldsIterable creates a new mock instance
func NewMockFieldsIterable(ctrl *gomock.Controller) *MockFieldsIterable {
	mock := &MockFieldsIterable{ctrl: ctrl}
	mock.recorder = &MockFieldsIterableMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockFieldsIterable) EXPECT() *MockFieldsIterableMockRecorder {
	return m.recorder
}

// Fields mocks base method
func (m *MockFieldsIterable) Fields() (FieldsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fields")
	ret0, _ := ret[0].(FieldsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fields indicates an expected call of Fields
func (mr *MockFieldsIterableMockRecorder) Fields() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fields", reflect.TypeOf((*MockFieldsIterable)(nil).Fields))
}

// MockTermsIterable is a mock of TermsIterable interface
type MockTermsIterable struct {
	ctrl     *gomock.Controller
	recorder *MockTermsIterableMockRecorder
}

// MockTermsIterableMockRecorder is the mock recorder for MockTermsIterable
type MockTermsIterableMockRecorder struct {
	mock *MockTermsIterable
}

// NewMockTermsIterable creates a new mock instance
func NewMockTermsIterable(ctrl *gomock.Controller) *MockTermsIterable {
	mock := &MockTermsIterable{ctrl: ctrl}
	mock.recorder = &MockTermsIterableMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockTermsIterable) EXPECT() *MockTermsIterableMockRecorder {
	return m.recorder
}

// Terms mocks base method
func (m *MockTermsIterable) Terms(field []byte) (TermsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Terms", field)
	ret0, _ := ret[0].(TermsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Terms indicates an expected call of Terms
func (mr *MockTermsIterableMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockTermsIterable)(nil).Terms), field)
}

// MockOrderedBytesIterator is a mock of OrderedBytesIterator interface
type MockOrderedBytesIterator struct {
	ctrl     *gomock.Controller
	recorder *MockOrderedBytesIteratorMockRecorder
}

// MockOrderedBytesIteratorMockRecorder is the mock recorder for MockOrderedBytesIterator
type MockOrderedBytesIteratorMockRecorder struct {
	mock *MockOrderedBytesIterator
}

// NewMockOrderedBytesIterator creates a new mock instance
func NewMockOrderedBytesIterator(ctrl *gomock.Controller) *MockOrderedBytesIterator {
	mock := &MockOrderedBytesIterator{ctrl: ctrl}
	mock.recorder = &MockOrderedBytesIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockOrderedBytesIterator) EXPECT() *MockOrderedBytesIteratorMockRecorder {
	return m.recorder
}

// Next mocks base method
func (m *MockOrderedBytesIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next
func (mr *MockOrderedBytesIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockOrderedBytesIterator)(nil).Next))
}

// Current mocks base method
func (m *MockOrderedBytesIterator) Current() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Current")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Current indicates an expected call of Current
func (mr *MockOrderedBytesIteratorMockRecorder) Current() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Current", reflect.TypeOf((*MockOrderedBytesIterator)(nil).Current))
}

// Err mocks base method
func (m *MockOrderedBytesIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err
func (mr *MockOrderedBytesIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockOrderedBytesIterator)(nil).Err))
}

// Close mocks base method
func (m *MockOrderedBytesIterator) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockOrderedBytesIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockOrderedBytesIterator)(nil).Close))
}

// MockFieldsIterator is a mock of FieldsIterator interface
type MockFieldsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockFieldsIteratorMockRecorder
}

// MockFieldsIteratorMockRecorder is the mock recorder for MockFieldsIterator
type MockFieldsIteratorMockRecorder struct {
	mock *MockFieldsIterator
}

// NewMockFieldsIterator creates a new mock instance
func NewMockFieldsIterator(ctrl *gomock.Controller) *MockFieldsIterator {
	mock := &MockFieldsIterator{ctrl: ctrl}
	mock.recorder = &MockFieldsIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockFieldsIterator) EXPECT() *MockFieldsIteratorMockRecorder {
	return m.recorder
}

// Next mocks base method
func (m *MockFieldsIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next
func (mr *MockFieldsIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockFieldsIterator)(nil).Next))
}

// Current mocks base method
func (m *MockFieldsIterator) Current() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Current")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Current indicates an expected call of Current
func (mr *MockFieldsIteratorMockRecorder) Current() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Current", reflect.TypeOf((*MockFieldsIterator)(nil).Current))
}

// Err mocks base method
func (m *MockFieldsIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err
func (mr *MockFieldsIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockFieldsIterator)(nil).Err))
}

// Close mocks base method
func (m *MockFieldsIterator) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockFieldsIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFieldsIterator)(nil).Close))
}

// MockTermsIterator is a mock of TermsIterator interface
type MockTermsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockTermsIteratorMockRecorder
}

// MockTermsIteratorMockRecorder is the mock recorder for MockTermsIterator
type MockTermsIteratorMockRecorder struct {
	mock *MockTermsIterator
}

// NewMockTermsIterator creates a new mock instance
func NewMockTermsIterator(ctrl *gomock.Controller) *MockTermsIterator {
	mock := &MockTermsIterator{ctrl: ctrl}
	mock.recorder = &MockTermsIteratorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockTermsIterator) EXPECT() *MockTermsIteratorMockRecorder {
	return m.recorder
}

// Next mocks base method
func (m *MockTermsIterator) Next() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Next indicates an expected call of Next
func (mr *MockTermsIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockTermsIterator)(nil).Next))
}

// Current mocks base method
func (m *MockTermsIterator) Current() ([]byte, postings.List) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Current")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(postings.List)
	return ret0, ret1
}

// Current indicates an expected call of Current
func (mr *MockTermsIteratorMockRecorder) Current() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Current", reflect.TypeOf((*MockTermsIterator)(nil).Current))
}

// Err mocks base method
func (m *MockTermsIterator) Err() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Err")
	ret0, _ := ret[0].(error)
	return ret0
}

// Err indicates an expected call of Err
func (mr *MockTermsIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockTermsIterator)(nil).Err))
}

// Close mocks base method
func (m *MockTermsIterator) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockTermsIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTermsIterator)(nil).Close))
}

// MockMutableSegment is a mock of MutableSegment interface
type MockMutableSegment struct {
	ctrl     *gomock.Controller
	recorder *MockMutableSegmentMockRecorder
}

// MockMutableSegmentMockRecorder is the mock recorder for MockMutableSegment
type MockMutableSegmentMockRecorder struct {
	mock *MockMutableSegment
}

// NewMockMutableSegment creates a new mock instance
func NewMockMutableSegment(ctrl *gomock.Controller) *MockMutableSegment {
	mock := &MockMutableSegment{ctrl: ctrl}
	mock.recorder = &MockMutableSegmentMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockMutableSegment) EXPECT() *MockMutableSegmentMockRecorder {
	return m.recorder
}

// FieldsIterable mocks base method
func (m *MockMutableSegment) FieldsIterable() FieldsIterable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FieldsIterable")
	ret0, _ := ret[0].(FieldsIterable)
	return ret0
}

// FieldsIterable indicates an expected call of FieldsIterable
func (mr *MockMutableSegmentMockRecorder) FieldsIterable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FieldsIterable", reflect.TypeOf((*MockMutableSegment)(nil).FieldsIterable))
}

// TermsIterable mocks base method
func (m *MockMutableSegment) TermsIterable() TermsIterable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TermsIterable")
	ret0, _ := ret[0].(TermsIterable)
	return ret0
}

// TermsIterable indicates an expected call of TermsIterable
func (mr *MockMutableSegmentMockRecorder) TermsIterable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TermsIterable", reflect.TypeOf((*MockMutableSegment)(nil).TermsIterable))
}

// Size mocks base method
func (m *MockMutableSegment) Size() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int64)
	return ret0
}

// Size indicates an expected call of Size
func (mr *MockMutableSegmentMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockMutableSegment)(nil).Size))
}

// ContainsID mocks base method
func (m *MockMutableSegment) ContainsID(docID []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainsID", docID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainsID indicates an expected call of ContainsID
func (mr *MockMutableSegmentMockRecorder) ContainsID(docID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsID", reflect.TypeOf((*MockMutableSegment)(nil).ContainsID), docID)
}

// ContainsField mocks base method
func (m *MockMutableSegment) ContainsField(field []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainsField", field)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainsField indicates an expected call of ContainsField
func (mr *MockMutableSegmentMockRecorder) ContainsField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsField", reflect.TypeOf((*MockMutableSegment)(nil).ContainsField), field)
}

// Reader mocks base method
func (m *MockMutableSegment) Reader() (index.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reader")
	ret0, _ := ret[0].(index.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Reader indicates an expected call of Reader
func (mr *MockMutableSegmentMockRecorder) Reader() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reader", reflect.TypeOf((*MockMutableSegment)(nil).Reader))
}

// Close mocks base method
func (m *MockMutableSegment) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockMutableSegmentMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockMutableSegment)(nil).Close))
}

// Fields mocks base method
func (m *MockMutableSegment) Fields() (FieldsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fields")
	ret0, _ := ret[0].(FieldsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fields indicates an expected call of Fields
func (mr *MockMutableSegmentMockRecorder) Fields() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fields", reflect.TypeOf((*MockMutableSegment)(nil).Fields))
}

// Terms mocks base method
func (m *MockMutableSegment) Terms(field []byte) (TermsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Terms", field)
	ret0, _ := ret[0].(TermsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Terms indicates an expected call of Terms
func (mr *MockMutableSegmentMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockMutableSegment)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockMutableSegment) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

// Reset indicates an expected call of Reset
func (mr *MockMutableSegmentMockRecorder) Reset(offset interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockMutableSegment)(nil).Reset), offset)
}

// Docs mocks base method
func (m *MockMutableSegment) Docs() []doc.Document {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Docs")
	ret0, _ := ret[0].([]doc.Document)
	return ret0
}

// Docs indicates an expected call of Docs
func (mr *MockMutableSegmentMockRecorder) Docs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Docs", reflect.TypeOf((*MockMutableSegment)(nil).Docs))
}

// AllDocs mocks base method
func (m *MockMutableSegment) AllDocs() (index.IDDocIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllDocs")
	ret0, _ := ret[0].(index.IDDocIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllDocs indicates an expected call of AllDocs
func (mr *MockMutableSegmentMockRecorder) AllDocs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllDocs", reflect.TypeOf((*MockMutableSegment)(nil).AllDocs))
}

// Insert mocks base method
func (m *MockMutableSegment) Insert(d doc.Document) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", d)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Insert indicates an expected call of Insert
func (mr *MockMutableSegmentMockRecorder) Insert(d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockMutableSegment)(nil).Insert), d)
}

// InsertBatch mocks base method
func (m *MockMutableSegment) InsertBatch(b index.Batch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertBatch", b)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertBatch indicates an expected call of InsertBatch
func (mr *MockMutableSegmentMockRecorder) InsertBatch(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertBatch", reflect.TypeOf((*MockMutableSegment)(nil).InsertBatch), b)
}

// Offset mocks base method
func (m *MockMutableSegment) Offset() postings.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Offset")
	ret0, _ := ret[0].(postings.ID)
	return ret0
}

// Offset indicates an expected call of Offset
func (mr *MockMutableSegmentMockRecorder) Offset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Offset", reflect.TypeOf((*MockMutableSegment)(nil).Offset))
}

// Seal mocks base method
func (m *MockMutableSegment) Seal() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seal")
	ret0, _ := ret[0].(error)
	return ret0
}

// Seal indicates an expected call of Seal
func (mr *MockMutableSegmentMockRecorder) Seal() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockMutableSegment)(nil).Seal))
}

// IsSealed mocks base method
func (m *MockMutableSegment) IsSealed() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSealed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsSealed indicates an expected call of IsSealed
func (mr *MockMutableSegmentMockRecorder) IsSealed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSealed", reflect.TypeOf((*MockMutableSegment)(nil).IsSealed))
}

// MockBuilder is a mock of Builder interface
type MockBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockBuilderMockRecorder
}

// MockBuilderMockRecorder is the mock recorder for MockBuilder
type MockBuilderMockRecorder struct {
	mock *MockBuilder
}

// NewMockBuilder creates a new mock instance
func NewMockBuilder(ctrl *gomock.Controller) *MockBuilder {
	mock := &MockBuilder{ctrl: ctrl}
	mock.recorder = &MockBuilderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockBuilder) EXPECT() *MockBuilderMockRecorder {
	return m.recorder
}

// Fields mocks base method
func (m *MockBuilder) Fields() (FieldsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fields")
	ret0, _ := ret[0].(FieldsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fields indicates an expected call of Fields
func (mr *MockBuilderMockRecorder) Fields() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fields", reflect.TypeOf((*MockBuilder)(nil).Fields))
}

// Terms mocks base method
func (m *MockBuilder) Terms(field []byte) (TermsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Terms", field)
	ret0, _ := ret[0].(TermsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Terms indicates an expected call of Terms
func (mr *MockBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

// Reset indicates an expected call of Reset
func (mr *MockBuilderMockRecorder) Reset(offset interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockBuilder)(nil).Reset), offset)
}

// Docs mocks base method
func (m *MockBuilder) Docs() []doc.Document {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Docs")
	ret0, _ := ret[0].([]doc.Document)
	return ret0
}

// Docs indicates an expected call of Docs
func (mr *MockBuilderMockRecorder) Docs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Docs", reflect.TypeOf((*MockBuilder)(nil).Docs))
}

// AllDocs mocks base method
func (m *MockBuilder) AllDocs() (index.IDDocIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllDocs")
	ret0, _ := ret[0].(index.IDDocIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllDocs indicates an expected call of AllDocs
func (mr *MockBuilderMockRecorder) AllDocs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllDocs", reflect.TypeOf((*MockBuilder)(nil).AllDocs))
}

// MockDocumentsBuilder is a mock of DocumentsBuilder interface
type MockDocumentsBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockDocumentsBuilderMockRecorder
}

// MockDocumentsBuilderMockRecorder is the mock recorder for MockDocumentsBuilder
type MockDocumentsBuilderMockRecorder struct {
	mock *MockDocumentsBuilder
}

// NewMockDocumentsBuilder creates a new mock instance
func NewMockDocumentsBuilder(ctrl *gomock.Controller) *MockDocumentsBuilder {
	mock := &MockDocumentsBuilder{ctrl: ctrl}
	mock.recorder = &MockDocumentsBuilderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockDocumentsBuilder) EXPECT() *MockDocumentsBuilderMockRecorder {
	return m.recorder
}

// Fields mocks base method
func (m *MockDocumentsBuilder) Fields() (FieldsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fields")
	ret0, _ := ret[0].(FieldsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fields indicates an expected call of Fields
func (mr *MockDocumentsBuilderMockRecorder) Fields() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fields", reflect.TypeOf((*MockDocumentsBuilder)(nil).Fields))
}

// Terms mocks base method
func (m *MockDocumentsBuilder) Terms(field []byte) (TermsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Terms", field)
	ret0, _ := ret[0].(TermsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Terms indicates an expected call of Terms
func (mr *MockDocumentsBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockDocumentsBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockDocumentsBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

// Reset indicates an expected call of Reset
func (mr *MockDocumentsBuilderMockRecorder) Reset(offset interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockDocumentsBuilder)(nil).Reset), offset)
}

// Docs mocks base method
func (m *MockDocumentsBuilder) Docs() []doc.Document {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Docs")
	ret0, _ := ret[0].([]doc.Document)
	return ret0
}

// Docs indicates an expected call of Docs
func (mr *MockDocumentsBuilderMockRecorder) Docs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Docs", reflect.TypeOf((*MockDocumentsBuilder)(nil).Docs))
}

// AllDocs mocks base method
func (m *MockDocumentsBuilder) AllDocs() (index.IDDocIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllDocs")
	ret0, _ := ret[0].(index.IDDocIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllDocs indicates an expected call of AllDocs
func (mr *MockDocumentsBuilderMockRecorder) AllDocs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllDocs", reflect.TypeOf((*MockDocumentsBuilder)(nil).AllDocs))
}

// Insert mocks base method
func (m *MockDocumentsBuilder) Insert(d doc.Document) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", d)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Insert indicates an expected call of Insert
func (mr *MockDocumentsBuilderMockRecorder) Insert(d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockDocumentsBuilder)(nil).Insert), d)
}

// InsertBatch mocks base method
func (m *MockDocumentsBuilder) InsertBatch(b index.Batch) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertBatch", b)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertBatch indicates an expected call of InsertBatch
func (mr *MockDocumentsBuilderMockRecorder) InsertBatch(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertBatch", reflect.TypeOf((*MockDocumentsBuilder)(nil).InsertBatch), b)
}

// MockSegmentsBuilder is a mock of SegmentsBuilder interface
type MockSegmentsBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockSegmentsBuilderMockRecorder
}

// MockSegmentsBuilderMockRecorder is the mock recorder for MockSegmentsBuilder
type MockSegmentsBuilderMockRecorder struct {
	mock *MockSegmentsBuilder
}

// NewMockSegmentsBuilder creates a new mock instance
func NewMockSegmentsBuilder(ctrl *gomock.Controller) *MockSegmentsBuilder {
	mock := &MockSegmentsBuilder{ctrl: ctrl}
	mock.recorder = &MockSegmentsBuilderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSegmentsBuilder) EXPECT() *MockSegmentsBuilderMockRecorder {
	return m.recorder
}

// Fields mocks base method
func (m *MockSegmentsBuilder) Fields() (FieldsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fields")
	ret0, _ := ret[0].(FieldsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fields indicates an expected call of Fields
func (mr *MockSegmentsBuilderMockRecorder) Fields() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fields", reflect.TypeOf((*MockSegmentsBuilder)(nil).Fields))
}

// Terms mocks base method
func (m *MockSegmentsBuilder) Terms(field []byte) (TermsIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Terms", field)
	ret0, _ := ret[0].(TermsIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Terms indicates an expected call of Terms
func (mr *MockSegmentsBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockSegmentsBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockSegmentsBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

// Reset indicates an expected call of Reset
func (mr *MockSegmentsBuilderMockRecorder) Reset(offset interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockSegmentsBuilder)(nil).Reset), offset)
}

// Docs mocks base method
func (m *MockSegmentsBuilder) Docs() []doc.Document {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Docs")
	ret0, _ := ret[0].([]doc.Document)
	return ret0
}

// Docs indicates an expected call of Docs
func (mr *MockSegmentsBuilderMockRecorder) Docs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Docs", reflect.TypeOf((*MockSegmentsBuilder)(nil).Docs))
}

// AllDocs mocks base method
func (m *MockSegmentsBuilder) AllDocs() (index.IDDocIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllDocs")
	ret0, _ := ret[0].(index.IDDocIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllDocs indicates an expected call of AllDocs
func (mr *MockSegmentsBuilderMockRecorder) AllDocs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllDocs", reflect.TypeOf((*MockSegmentsBuilder)(nil).AllDocs))
}

// AddSegments mocks base method
func (m *MockSegmentsBuilder) AddSegments(segments []Segment) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSegments", segments)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSegments indicates an expected call of AddSegments
func (mr *MockSegmentsBuilderMockRecorder) AddSegments(segments interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSegments", reflect.TypeOf((*MockSegmentsBuilder)(nil).AddSegments), segments)
}