index_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/dbnode/storage/index/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 index is a generated GoMock package.
package index

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/clock"
	"github.com/m3db/m3/src/dbnode/storage/bootstrap/result"
	"github.com/m3db/m3/src/dbnode/storage/index/compaction"
	"github.com/m3db/m3/src/m3ninx/doc"
	"github.com/m3db/m3/src/m3ninx/index/segment"
	"github.com/m3db/m3/src/m3ninx/index/segment/builder"
	"github.com/m3db/m3/src/m3ninx/index/segment/fst"
	"github.com/m3db/m3/src/m3ninx/index/segment/mem"
	"github.com/m3db/m3/src/x/context"
	"github.com/m3db/m3/src/x/ident"
	"github.com/m3db/m3/src/x/instrument"
	"github.com/m3db/m3/src/x/pool"
	"github.com/m3db/m3/src/x/resource"
	time0 "github.com/m3db/m3/src/x/time"

	"github.com/golang/mock/gomock"
	"github.com/opentracing/opentracing-go/log"
)

// MockBaseResults is a mock of BaseResults interface
type MockBaseResults struct {
	ctrl     *gomock.Controller
	recorder *MockBaseResultsMockRecorder
}

// MockBaseResultsMockRecorder is the mock recorder for MockBaseResults
type MockBaseResultsMockRecorder struct {
	mock *MockBaseResults
}

// NewMockBaseResults creates a new mock instance
func NewMockBaseResults(ctrl *gomock.Controller) *MockBaseResults {
	mock := &MockBaseResults{ctrl: ctrl}
	mock.recorder = &MockBaseResultsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// AddDocuments indicates an expected call of AddDocuments
func (mr *MockBaseResultsMockRecorder) AddDocuments(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocuments", reflect.TypeOf((*MockBaseResults)(nil).AddDocuments), batch)
}

// Finalize mocks base method
func (m *MockBaseResults) Finalize() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Finalize")
}

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

// MockQueryResults is a mock of QueryResults interface
type MockQueryResults struct {
	ctrl     *gomock.Controller
	recorder *MockQueryResultsMockRecorder
}

// MockQueryResultsMockRecorder is the mock recorder for MockQueryResults
type MockQueryResultsMockRecorder struct {
	mock *MockQueryResults
}

// NewMockQueryResults creates a new mock instance
func NewMockQueryResults(ctrl *gomock.Controller) *MockQueryResults {
	mock := &MockQueryResults{ctrl: ctrl}
	mock.recorder = &MockQueryResultsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// AddDocuments indicates an expected call of AddDocuments
func (mr *MockQueryResultsMockRecorder) AddDocuments(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocuments", reflect.TypeOf((*MockQueryResults)(nil).AddDocuments), batch)
}

// Finalize mocks base method
func (m *MockQueryResults) Finalize() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Finalize")
}

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

// Reset mocks base method
func (m *MockQueryResults) Reset(nsID ident.ID, opts QueryResultsOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", nsID, opts)
}

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

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

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

// NoFinalize mocks base method
func (m *MockQueryResults) NoFinalize() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NoFinalize")
}

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

// MockQueryResultsPool is a mock of QueryResultsPool interface
type MockQueryResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockQueryResultsPoolMockRecorder
}

// MockQueryResultsPoolMockRecorder is the mock recorder for MockQueryResultsPool
type MockQueryResultsPoolMockRecorder struct {
	mock *MockQueryResultsPool
}

// NewMockQueryResultsPool creates a new mock instance
func NewMockQueryResultsPool(ctrl *gomock.Controller) *MockQueryResultsPool {
	mock := &MockQueryResultsPool{ctrl: ctrl}
	mock.recorder = &MockQueryResultsPoolMockRecorder{mock}
	return mock
}

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

// Init mocks base method
func (m *MockQueryResultsPool) Init(alloc QueryResultsAllocator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init", alloc)
}

// Init indicates an expected call of Init
func (mr *MockQueryResultsPoolMockRecorder) Init(alloc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockQueryResultsPool)(nil).Init), alloc)
}

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

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

// Put mocks base method
func (m *MockQueryResultsPool) Put(value QueryResults) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", value)
}

// Put indicates an expected call of Put
func (mr *MockQueryResultsPoolMockRecorder) Put(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockQueryResultsPool)(nil).Put), value)
}

// MockAggregateResults is a mock of AggregateResults interface
type MockAggregateResults struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateResultsMockRecorder
}

// MockAggregateResultsMockRecorder is the mock recorder for MockAggregateResults
type MockAggregateResultsMockRecorder struct {
	mock *MockAggregateResults
}

// NewMockAggregateResults creates a new mock instance
func NewMockAggregateResults(ctrl *gomock.Controller) *MockAggregateResults {
	mock := &MockAggregateResults{ctrl: ctrl}
	mock.recorder = &MockAggregateResultsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// AddDocuments indicates an expected call of AddDocuments
func (mr *MockAggregateResultsMockRecorder) AddDocuments(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocuments", reflect.TypeOf((*MockAggregateResults)(nil).AddDocuments), batch)
}

// Finalize mocks base method
func (m *MockAggregateResults) Finalize() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Finalize")
}

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

// Reset mocks base method
func (m *MockAggregateResults) Reset(nsID ident.ID, aggregateQueryOpts AggregateResultsOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", nsID, aggregateQueryOpts)
}

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

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

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

// AddFields mocks base method
func (m *MockAggregateResults) AddFields(batch []AggregateResultsEntry) int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddFields", batch)
	ret0, _ := ret[0].(int)
	return ret0
}

// AddFields indicates an expected call of AddFields
func (mr *MockAggregateResultsMockRecorder) AddFields(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFields", reflect.TypeOf((*MockAggregateResults)(nil).AddFields), batch)
}

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

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

// MockAggregateResultsPool is a mock of AggregateResultsPool interface
type MockAggregateResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateResultsPoolMockRecorder
}

// MockAggregateResultsPoolMockRecorder is the mock recorder for MockAggregateResultsPool
type MockAggregateResultsPoolMockRecorder struct {
	mock *MockAggregateResultsPool
}

// NewMockAggregateResultsPool creates a new mock instance
func NewMockAggregateResultsPool(ctrl *gomock.Controller) *MockAggregateResultsPool {
	mock := &MockAggregateResultsPool{ctrl: ctrl}
	mock.recorder = &MockAggregateResultsPoolMockRecorder{mock}
	return mock
}

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

// Init mocks base method
func (m *MockAggregateResultsPool) Init(alloc AggregateResultsAllocator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init", alloc)
}

// Init indicates an expected call of Init
func (mr *MockAggregateResultsPoolMockRecorder) Init(alloc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAggregateResultsPool)(nil).Init), alloc)
}

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

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

// Put mocks base method
func (m *MockAggregateResultsPool) Put(value AggregateResults) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", value)
}

// Put indicates an expected call of Put
func (mr *MockAggregateResultsPoolMockRecorder) Put(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockAggregateResultsPool)(nil).Put), value)
}

// MockAggregateValuesPool is a mock of AggregateValuesPool interface
type MockAggregateValuesPool struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateValuesPoolMockRecorder
}

// MockAggregateValuesPoolMockRecorder is the mock recorder for MockAggregateValuesPool
type MockAggregateValuesPoolMockRecorder struct {
	mock *MockAggregateValuesPool
}

// NewMockAggregateValuesPool creates a new mock instance
func NewMockAggregateValuesPool(ctrl *gomock.Controller) *MockAggregateValuesPool {
	mock := &MockAggregateValuesPool{ctrl: ctrl}
	mock.recorder = &MockAggregateValuesPoolMockRecorder{mock}
	return mock
}

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

// Init mocks base method
func (m *MockAggregateValuesPool) Init(alloc AggregateValuesAllocator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init", alloc)
}

// Init indicates an expected call of Init
func (mr *MockAggregateValuesPoolMockRecorder) Init(alloc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockAggregateValuesPool)(nil).Init), alloc)
}

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

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

// Put mocks base method
func (m *MockAggregateValuesPool) Put(value AggregateValues) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", value)
}

// Put indicates an expected call of Put
func (mr *MockAggregateValuesPoolMockRecorder) Put(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockAggregateValuesPool)(nil).Put), value)
}

// MockOnIndexSeries is a mock of OnIndexSeries interface
type MockOnIndexSeries struct {
	ctrl     *gomock.Controller
	recorder *MockOnIndexSeriesMockRecorder
}

// MockOnIndexSeriesMockRecorder is the mock recorder for MockOnIndexSeries
type MockOnIndexSeriesMockRecorder struct {
	mock *MockOnIndexSeries
}

// NewMockOnIndexSeries creates a new mock instance
func NewMockOnIndexSeries(ctrl *gomock.Controller) *MockOnIndexSeries {
	mock := &MockOnIndexSeries{ctrl: ctrl}
	mock.recorder = &MockOnIndexSeriesMockRecorder{mock}
	return mock
}

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

// OnIndexSuccess mocks base method
func (m *MockOnIndexSeries) OnIndexSuccess(blockStart time0.UnixNano) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnIndexSuccess", blockStart)
}

// OnIndexSuccess indicates an expected call of OnIndexSuccess
func (mr *MockOnIndexSeriesMockRecorder) OnIndexSuccess(blockStart interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnIndexSuccess", reflect.TypeOf((*MockOnIndexSeries)(nil).OnIndexSuccess), blockStart)
}

// OnIndexFinalize mocks base method
func (m *MockOnIndexSeries) OnIndexFinalize(blockStart time0.UnixNano) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnIndexFinalize", blockStart)
}

// OnIndexFinalize indicates an expected call of OnIndexFinalize
func (mr *MockOnIndexSeriesMockRecorder) OnIndexFinalize(blockStart interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnIndexFinalize", reflect.TypeOf((*MockOnIndexSeries)(nil).OnIndexFinalize), blockStart)
}

// OnIndexPrepare mocks base method
func (m *MockOnIndexSeries) OnIndexPrepare() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnIndexPrepare")
}

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

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

// NeedsIndexUpdate indicates an expected call of NeedsIndexUpdate
func (mr *MockOnIndexSeriesMockRecorder) NeedsIndexUpdate(indexBlockStartForWrite interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeedsIndexUpdate", reflect.TypeOf((*MockOnIndexSeries)(nil).NeedsIndexUpdate), indexBlockStartForWrite)
}

// MockBlock is a mock of Block interface
type MockBlock struct {
	ctrl     *gomock.Controller
	recorder *MockBlockMockRecorder
}

// MockBlockMockRecorder is the mock recorder for MockBlock
type MockBlockMockRecorder struct {
	mock *MockBlock
}

// NewMockBlock creates a new mock instance
func NewMockBlock(ctrl *gomock.Controller) *MockBlock {
	mock := &MockBlock{ctrl: ctrl}
	mock.recorder = &MockBlockMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// WriteBatch indicates an expected call of WriteBatch
func (mr *MockBlockMockRecorder) WriteBatch(inserts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatch", reflect.TypeOf((*MockBlock)(nil).WriteBatch), inserts)
}

// Query mocks base method
func (m *MockBlock) Query(ctx context.Context, cancellable *resource.CancellableLifetime, query Query, opts QueryOptions, results BaseResults, logFields []log.Field) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", ctx, cancellable, query, opts, results, logFields)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query
func (mr *MockBlockMockRecorder) Query(ctx, cancellable, query, opts, results, logFields interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockBlock)(nil).Query), ctx, cancellable, query, opts, results, logFields)
}

// Aggregate mocks base method
func (m *MockBlock) Aggregate(ctx context.Context, cancellable *resource.CancellableLifetime, opts QueryOptions, results AggregateResults, logFields []log.Field) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Aggregate", ctx, cancellable, opts, results, logFields)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Aggregate indicates an expected call of Aggregate
func (mr *MockBlockMockRecorder) Aggregate(ctx, cancellable, opts, results, logFields interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockBlock)(nil).Aggregate), ctx, cancellable, opts, results, logFields)
}

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

// AddResults indicates an expected call of AddResults
func (mr *MockBlockMockRecorder) AddResults(results interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResults", reflect.TypeOf((*MockBlock)(nil).AddResults), results)
}

// Tick mocks base method
func (m *MockBlock) Tick(c context.Cancellable) (BlockTickResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tick", c)
	ret0, _ := ret[0].(BlockTickResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Tick indicates an expected call of Tick
func (mr *MockBlockMockRecorder) Tick(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tick", reflect.TypeOf((*MockBlock)(nil).Tick), c)
}

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

// Stats indicates an expected call of Stats
func (mr *MockBlockMockRecorder) Stats(reporter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockBlock)(nil).Stats), reporter)
}

// Seal mocks base method
func (m *MockBlock) 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 *MockBlockMockRecorder) Seal() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockBlock)(nil).Seal))
}

// IsSealed mocks base method
func (m *MockBlock) 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 *MockBlockMockRecorder) IsSealed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSealed", reflect.TypeOf((*MockBlock)(nil).IsSealed))
}

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

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

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

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

// Close mocks base method
func (m *MockBlock) 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 *MockBlockMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockBlock)(nil).Close))
}

// MockBlockStatsReporter is a mock of BlockStatsReporter interface
type MockBlockStatsReporter struct {
	ctrl     *gomock.Controller
	recorder *MockBlockStatsReporterMockRecorder
}

// MockBlockStatsReporterMockRecorder is the mock recorder for MockBlockStatsReporter
type MockBlockStatsReporterMockRecorder struct {
	mock *MockBlockStatsReporter
}

// NewMockBlockStatsReporter creates a new mock instance
func NewMockBlockStatsReporter(ctrl *gomock.Controller) *MockBlockStatsReporter {
	mock := &MockBlockStatsReporter{ctrl: ctrl}
	mock.recorder = &MockBlockStatsReporterMockRecorder{mock}
	return mock
}

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

// ReportSegmentStats mocks base method
func (m *MockBlockStatsReporter) ReportSegmentStats(stats BlockSegmentStats) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReportSegmentStats", stats)
}

// ReportSegmentStats indicates an expected call of ReportSegmentStats
func (mr *MockBlockStatsReporterMockRecorder) ReportSegmentStats(stats interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportSegmentStats", reflect.TypeOf((*MockBlockStatsReporter)(nil).ReportSegmentStats), stats)
}

// MockfieldsAndTermsIterator is a mock of fieldsAndTermsIterator interface
type MockfieldsAndTermsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockfieldsAndTermsIteratorMockRecorder
}

// MockfieldsAndTermsIteratorMockRecorder is the mock recorder for MockfieldsAndTermsIterator
type MockfieldsAndTermsIteratorMockRecorder struct {
	mock *MockfieldsAndTermsIterator
}

// NewMockfieldsAndTermsIterator creates a new mock instance
func NewMockfieldsAndTermsIterator(ctrl *gomock.Controller) *MockfieldsAndTermsIterator {
	mock := &MockfieldsAndTermsIterator{ctrl: ctrl}
	mock.recorder = &MockfieldsAndTermsIteratorMockRecorder{mock}
	return mock
}

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

// Next mocks base method
func (m *MockfieldsAndTermsIterator) 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 *MockfieldsAndTermsIteratorMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockfieldsAndTermsIterator)(nil).Next))
}

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

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

// Err mocks base method
func (m *MockfieldsAndTermsIterator) 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 *MockfieldsAndTermsIteratorMockRecorder) Err() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockfieldsAndTermsIterator)(nil).Err))
}

// Close mocks base method
func (m *MockfieldsAndTermsIterator) 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 *MockfieldsAndTermsIteratorMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockfieldsAndTermsIterator)(nil).Close))
}

// Reset mocks base method
func (m *MockfieldsAndTermsIterator) Reset(seg segment.Segment, opts fieldsAndTermsIteratorOpts) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reset", seg, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockOptions is a mock of Options interface
type MockOptions struct {
	ctrl     *gomock.Controller
	recorder *MockOptionsMockRecorder
}

// MockOptionsMockRecorder is the mock recorder for MockOptions
type MockOptionsMockRecorder struct {
	mock *MockOptions
}

// NewMockOptions creates a new mock instance
func NewMockOptions(ctrl *gomock.Controller) *MockOptions {
	mock := &MockOptions{ctrl: ctrl}
	mock.recorder = &MockOptionsMockRecorder{mock}
	return mock
}

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

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

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

// SetInsertMode mocks base method
func (m *MockOptions) SetInsertMode(value InsertMode) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInsertMode", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetInsertMode indicates an expected call of SetInsertMode
func (mr *MockOptionsMockRecorder) SetInsertMode(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInsertMode", reflect.TypeOf((*MockOptions)(nil).SetInsertMode), value)
}

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

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

// SetClockOptions mocks base method
func (m *MockOptions) SetClockOptions(value clock.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetClockOptions", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetClockOptions indicates an expected call of SetClockOptions
func (mr *MockOptionsMockRecorder) SetClockOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetClockOptions", reflect.TypeOf((*MockOptions)(nil).SetClockOptions), value)
}

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

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

// SetInstrumentOptions mocks base method
func (m *MockOptions) SetInstrumentOptions(value instrument.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstrumentOptions", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetInstrumentOptions indicates an expected call of SetInstrumentOptions
func (mr *MockOptionsMockRecorder) SetInstrumentOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstrumentOptions", reflect.TypeOf((*MockOptions)(nil).SetInstrumentOptions), value)
}

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

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

// SetSegmentBuilderOptions mocks base method
func (m *MockOptions) SetSegmentBuilderOptions(value builder.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSegmentBuilderOptions", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetSegmentBuilderOptions indicates an expected call of SetSegmentBuilderOptions
func (mr *MockOptionsMockRecorder) SetSegmentBuilderOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSegmentBuilderOptions", reflect.TypeOf((*MockOptions)(nil).SetSegmentBuilderOptions), value)
}

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

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

// SetMemSegmentOptions mocks base method
func (m *MockOptions) SetMemSegmentOptions(value mem.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMemSegmentOptions", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetMemSegmentOptions indicates an expected call of SetMemSegmentOptions
func (mr *MockOptionsMockRecorder) SetMemSegmentOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMemSegmentOptions", reflect.TypeOf((*MockOptions)(nil).SetMemSegmentOptions), value)
}

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

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

// SetFSTSegmentOptions mocks base method
func (m *MockOptions) SetFSTSegmentOptions(value fst.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFSTSegmentOptions", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetFSTSegmentOptions indicates an expected call of SetFSTSegmentOptions
func (mr *MockOptionsMockRecorder) SetFSTSegmentOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFSTSegmentOptions", reflect.TypeOf((*MockOptions)(nil).SetFSTSegmentOptions), value)
}

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

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

// SetIdentifierPool mocks base method
func (m *MockOptions) SetIdentifierPool(value ident.Pool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIdentifierPool", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIdentifierPool indicates an expected call of SetIdentifierPool
func (mr *MockOptionsMockRecorder) SetIdentifierPool(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIdentifierPool", reflect.TypeOf((*MockOptions)(nil).SetIdentifierPool), value)
}

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

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

// SetCheckedBytesPool mocks base method
func (m *MockOptions) SetCheckedBytesPool(value pool.CheckedBytesPool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCheckedBytesPool", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetCheckedBytesPool indicates an expected call of SetCheckedBytesPool
func (mr *MockOptionsMockRecorder) SetCheckedBytesPool(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCheckedBytesPool", reflect.TypeOf((*MockOptions)(nil).SetCheckedBytesPool), value)
}

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

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

// SetQueryResultsPool mocks base method
func (m *MockOptions) SetQueryResultsPool(values QueryResultsPool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetQueryResultsPool", values)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetQueryResultsPool indicates an expected call of SetQueryResultsPool
func (mr *MockOptionsMockRecorder) SetQueryResultsPool(values interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueryResultsPool", reflect.TypeOf((*MockOptions)(nil).SetQueryResultsPool), values)
}

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

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

// SetAggregateResultsPool mocks base method
func (m *MockOptions) SetAggregateResultsPool(values AggregateResultsPool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAggregateResultsPool", values)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetAggregateResultsPool indicates an expected call of SetAggregateResultsPool
func (mr *MockOptionsMockRecorder) SetAggregateResultsPool(values interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAggregateResultsPool", reflect.TypeOf((*MockOptions)(nil).SetAggregateResultsPool), values)
}

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

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

// SetAggregateValuesPool mocks base method
func (m *MockOptions) SetAggregateValuesPool(values AggregateValuesPool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAggregateValuesPool", values)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetAggregateValuesPool indicates an expected call of SetAggregateValuesPool
func (mr *MockOptionsMockRecorder) SetAggregateValuesPool(values interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAggregateValuesPool", reflect.TypeOf((*MockOptions)(nil).SetAggregateValuesPool), values)
}

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

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

// SetDocumentArrayPool mocks base method
func (m *MockOptions) SetDocumentArrayPool(value doc.DocumentArrayPool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDocumentArrayPool", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetDocumentArrayPool indicates an expected call of SetDocumentArrayPool
func (mr *MockOptionsMockRecorder) SetDocumentArrayPool(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDocumentArrayPool", reflect.TypeOf((*MockOptions)(nil).SetDocumentArrayPool), value)
}

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

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

// SetAggregateResultsEntryArrayPool mocks base method
func (m *MockOptions) SetAggregateResultsEntryArrayPool(value AggregateResultsEntryArrayPool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAggregateResultsEntryArrayPool", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetAggregateResultsEntryArrayPool indicates an expected call of SetAggregateResultsEntryArrayPool
func (mr *MockOptionsMockRecorder) SetAggregateResultsEntryArrayPool(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAggregateResultsEntryArrayPool", reflect.TypeOf((*MockOptions)(nil).SetAggregateResultsEntryArrayPool), value)
}

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

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

// SetForegroundCompactionPlannerOptions mocks base method
func (m *MockOptions) SetForegroundCompactionPlannerOptions(v compaction.PlannerOptions) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetForegroundCompactionPlannerOptions", v)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetForegroundCompactionPlannerOptions indicates an expected call of SetForegroundCompactionPlannerOptions
func (mr *MockOptionsMockRecorder) SetForegroundCompactionPlannerOptions(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForegroundCompactionPlannerOptions", reflect.TypeOf((*MockOptions)(nil).SetForegroundCompactionPlannerOptions), v)
}

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

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

// SetBackgroundCompactionPlannerOptions mocks base method
func (m *MockOptions) SetBackgroundCompactionPlannerOptions(v compaction.PlannerOptions) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBackgroundCompactionPlannerOptions", v)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetBackgroundCompactionPlannerOptions indicates an expected call of SetBackgroundCompactionPlannerOptions
func (mr *MockOptionsMockRecorder) SetBackgroundCompactionPlannerOptions(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackgroundCompactionPlannerOptions", reflect.TypeOf((*MockOptions)(nil).SetBackgroundCompactionPlannerOptions), v)
}

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

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

// SetPostingsListCache mocks base method
func (m *MockOptions) SetPostingsListCache(value *PostingsListCache) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPostingsListCache", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetPostingsListCache indicates an expected call of SetPostingsListCache
func (mr *MockOptionsMockRecorder) SetPostingsListCache(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPostingsListCache", reflect.TypeOf((*MockOptions)(nil).SetPostingsListCache), value)
}

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

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

// SetReadThroughSegmentOptions mocks base method
func (m *MockOptions) SetReadThroughSegmentOptions(value ReadThroughSegmentOptions) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetReadThroughSegmentOptions", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetReadThroughSegmentOptions indicates an expected call of SetReadThroughSegmentOptions
func (mr *MockOptionsMockRecorder) SetReadThroughSegmentOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadThroughSegmentOptions", reflect.TypeOf((*MockOptions)(nil).SetReadThroughSegmentOptions), value)
}

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

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

// SetForwardIndexProbability mocks base method
func (m *MockOptions) SetForwardIndexProbability(value float64) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetForwardIndexProbability", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetForwardIndexProbability indicates an expected call of SetForwardIndexProbability
func (mr *MockOptionsMockRecorder) SetForwardIndexProbability(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForwardIndexProbability", reflect.TypeOf((*MockOptions)(nil).SetForwardIndexProbability), value)
}

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

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

// SetForwardIndexThreshold mocks base method
func (m *MockOptions) SetForwardIndexThreshold(value float64) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetForwardIndexThreshold", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetForwardIndexThreshold indicates an expected call of SetForwardIndexThreshold
func (mr *MockOptionsMockRecorder) SetForwardIndexThreshold(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForwardIndexThreshold", reflect.TypeOf((*MockOptions)(nil).SetForwardIndexThreshold), value)
}

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

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