block_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/dbnode/storage/block/types.go

// Copyright (c) 2018 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 block is a generated GoMock package.
package block

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/encoding"
	"github.com/m3db/m3/src/dbnode/storage/namespace"
	"github.com/m3db/m3/src/dbnode/ts"
	"github.com/m3db/m3/src/dbnode/x/xio"
	"github.com/m3db/m3x/clock"
	"github.com/m3db/m3x/context"
	"github.com/m3db/m3x/ident"
	"github.com/m3db/m3x/pool"
	"github.com/m3db/m3x/sync"
	time0 "github.com/m3db/m3x/time"

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

// MockFilteredBlocksMetadataIter is a mock of FilteredBlocksMetadataIter interface
type MockFilteredBlocksMetadataIter struct {
	ctrl     *gomock.Controller
	recorder *MockFilteredBlocksMetadataIterMockRecorder
}

// MockFilteredBlocksMetadataIterMockRecorder is the mock recorder for MockFilteredBlocksMetadataIter
type MockFilteredBlocksMetadataIterMockRecorder struct {
	mock *MockFilteredBlocksMetadataIter
}

// NewMockFilteredBlocksMetadataIter creates a new mock instance
func NewMockFilteredBlocksMetadataIter(ctrl *gomock.Controller) *MockFilteredBlocksMetadataIter {
	mock := &MockFilteredBlocksMetadataIter{ctrl: ctrl}
	mock.recorder = &MockFilteredBlocksMetadataIterMockRecorder{mock}
	return mock
}

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

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

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

// Current mocks base method
func (m *MockFilteredBlocksMetadataIter) Current() (ident.ID, Metadata) {
	ret := m.ctrl.Call(m, "Current")
	ret0, _ := ret[0].(ident.ID)
	ret1, _ := ret[1].(Metadata)
	return ret0, ret1
}

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

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

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

// MockFetchBlockMetadataResults is a mock of FetchBlockMetadataResults interface
type MockFetchBlockMetadataResults struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlockMetadataResultsMockRecorder
}

// MockFetchBlockMetadataResultsMockRecorder is the mock recorder for MockFetchBlockMetadataResults
type MockFetchBlockMetadataResultsMockRecorder struct {
	mock *MockFetchBlockMetadataResults
}

// NewMockFetchBlockMetadataResults creates a new mock instance
func NewMockFetchBlockMetadataResults(ctrl *gomock.Controller) *MockFetchBlockMetadataResults {
	mock := &MockFetchBlockMetadataResults{ctrl: ctrl}
	mock.recorder = &MockFetchBlockMetadataResultsMockRecorder{mock}
	return mock
}

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

// Add mocks base method
func (m *MockFetchBlockMetadataResults) Add(res FetchBlockMetadataResult) {
	m.ctrl.Call(m, "Add", res)
}

// Add indicates an expected call of Add
func (mr *MockFetchBlockMetadataResultsMockRecorder) Add(res interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockFetchBlockMetadataResults)(nil).Add), res)
}

// Results mocks base method
func (m *MockFetchBlockMetadataResults) Results() []FetchBlockMetadataResult {
	ret := m.ctrl.Call(m, "Results")
	ret0, _ := ret[0].([]FetchBlockMetadataResult)
	return ret0
}

// Results indicates an expected call of Results
func (mr *MockFetchBlockMetadataResultsMockRecorder) Results() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Results", reflect.TypeOf((*MockFetchBlockMetadataResults)(nil).Results))
}

// Sort mocks base method
func (m *MockFetchBlockMetadataResults) Sort() {
	m.ctrl.Call(m, "Sort")
}

// Sort indicates an expected call of Sort
func (mr *MockFetchBlockMetadataResultsMockRecorder) Sort() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockFetchBlockMetadataResults)(nil).Sort))
}

// Reset mocks base method
func (m *MockFetchBlockMetadataResults) Reset() {
	m.ctrl.Call(m, "Reset")
}

// Reset indicates an expected call of Reset
func (mr *MockFetchBlockMetadataResultsMockRecorder) Reset() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockFetchBlockMetadataResults)(nil).Reset))
}

// Close mocks base method
func (m *MockFetchBlockMetadataResults) Close() {
	m.ctrl.Call(m, "Close")
}

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

// MockFetchBlocksMetadataResults is a mock of FetchBlocksMetadataResults interface
type MockFetchBlocksMetadataResults struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlocksMetadataResultsMockRecorder
}

// MockFetchBlocksMetadataResultsMockRecorder is the mock recorder for MockFetchBlocksMetadataResults
type MockFetchBlocksMetadataResultsMockRecorder struct {
	mock *MockFetchBlocksMetadataResults
}

// NewMockFetchBlocksMetadataResults creates a new mock instance
func NewMockFetchBlocksMetadataResults(ctrl *gomock.Controller) *MockFetchBlocksMetadataResults {
	mock := &MockFetchBlocksMetadataResults{ctrl: ctrl}
	mock.recorder = &MockFetchBlocksMetadataResultsMockRecorder{mock}
	return mock
}

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

// Add mocks base method
func (m *MockFetchBlocksMetadataResults) Add(res FetchBlocksMetadataResult) {
	m.ctrl.Call(m, "Add", res)
}

// Add indicates an expected call of Add
func (mr *MockFetchBlocksMetadataResultsMockRecorder) Add(res interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockFetchBlocksMetadataResults)(nil).Add), res)
}

// Results mocks base method
func (m *MockFetchBlocksMetadataResults) Results() []FetchBlocksMetadataResult {
	ret := m.ctrl.Call(m, "Results")
	ret0, _ := ret[0].([]FetchBlocksMetadataResult)
	return ret0
}

// Results indicates an expected call of Results
func (mr *MockFetchBlocksMetadataResultsMockRecorder) Results() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Results", reflect.TypeOf((*MockFetchBlocksMetadataResults)(nil).Results))
}

// Reset mocks base method
func (m *MockFetchBlocksMetadataResults) Reset() {
	m.ctrl.Call(m, "Reset")
}

// Reset indicates an expected call of Reset
func (mr *MockFetchBlocksMetadataResultsMockRecorder) Reset() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockFetchBlocksMetadataResults)(nil).Reset))
}

// Close mocks base method
func (m *MockFetchBlocksMetadataResults) Close() {
	m.ctrl.Call(m, "Close")
}

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

// MockDatabaseBlock is a mock of DatabaseBlock interface
type MockDatabaseBlock struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockMockRecorder
}

// MockDatabaseBlockMockRecorder is the mock recorder for MockDatabaseBlock
type MockDatabaseBlockMockRecorder struct {
	mock *MockDatabaseBlock
}

// NewMockDatabaseBlock creates a new mock instance
func NewMockDatabaseBlock(ctrl *gomock.Controller) *MockDatabaseBlock {
	mock := &MockDatabaseBlock{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockMockRecorder{mock}
	return mock
}

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

// OnRetrieveBlock mocks base method
func (m *MockDatabaseBlock) OnRetrieveBlock(id ident.ID, tags ident.TagIterator, startTime time.Time, segment ts.Segment) {
	m.ctrl.Call(m, "OnRetrieveBlock", id, tags, startTime, segment)
}

// OnRetrieveBlock indicates an expected call of OnRetrieveBlock
func (mr *MockDatabaseBlockMockRecorder) OnRetrieveBlock(id, tags, startTime, segment interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetrieveBlock", reflect.TypeOf((*MockDatabaseBlock)(nil).OnRetrieveBlock), id, tags, startTime, segment)
}

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

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

// BlockSize mocks base method
func (m *MockDatabaseBlock) BlockSize() time.Duration {
	ret := m.ctrl.Call(m, "BlockSize")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

// BlockSize indicates an expected call of BlockSize
func (mr *MockDatabaseBlockMockRecorder) BlockSize() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockSize", reflect.TypeOf((*MockDatabaseBlock)(nil).BlockSize))
}

// SetLastReadTime mocks base method
func (m *MockDatabaseBlock) SetLastReadTime(value time.Time) {
	m.ctrl.Call(m, "SetLastReadTime", value)
}

// SetLastReadTime indicates an expected call of SetLastReadTime
func (mr *MockDatabaseBlockMockRecorder) SetLastReadTime(value interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastReadTime", reflect.TypeOf((*MockDatabaseBlock)(nil).SetLastReadTime), value)
}

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

// LastReadTime indicates an expected call of LastReadTime
func (mr *MockDatabaseBlockMockRecorder) LastReadTime() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastReadTime", reflect.TypeOf((*MockDatabaseBlock)(nil).LastReadTime))
}

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

// Len indicates an expected call of Len
func (mr *MockDatabaseBlockMockRecorder) Len() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockDatabaseBlock)(nil).Len))
}

// Checksum mocks base method
func (m *MockDatabaseBlock) Checksum() (uint32, error) {
	ret := m.ctrl.Call(m, "Checksum")
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Checksum indicates an expected call of Checksum
func (mr *MockDatabaseBlockMockRecorder) Checksum() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Checksum", reflect.TypeOf((*MockDatabaseBlock)(nil).Checksum))
}

// Stream mocks base method
func (m *MockDatabaseBlock) Stream(blocker context.Context) (xio.BlockReader, error) {
	ret := m.ctrl.Call(m, "Stream", blocker)
	ret0, _ := ret[0].(xio.BlockReader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stream indicates an expected call of Stream
func (mr *MockDatabaseBlockMockRecorder) Stream(blocker interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDatabaseBlock)(nil).Stream), blocker)
}

// Merge mocks base method
func (m *MockDatabaseBlock) Merge(other DatabaseBlock) error {
	ret := m.ctrl.Call(m, "Merge", other)
	ret0, _ := ret[0].(error)
	return ret0
}

// Merge indicates an expected call of Merge
func (mr *MockDatabaseBlockMockRecorder) Merge(other interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Merge", reflect.TypeOf((*MockDatabaseBlock)(nil).Merge), other)
}

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

// HasMergeTarget indicates an expected call of HasMergeTarget
func (mr *MockDatabaseBlockMockRecorder) HasMergeTarget() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasMergeTarget", reflect.TypeOf((*MockDatabaseBlock)(nil).HasMergeTarget))
}

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

// IsRetrieved indicates an expected call of IsRetrieved
func (mr *MockDatabaseBlockMockRecorder) IsRetrieved() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRetrieved", reflect.TypeOf((*MockDatabaseBlock)(nil).IsRetrieved))
}

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

// WasRetrievedFromDisk indicates an expected call of WasRetrievedFromDisk
func (mr *MockDatabaseBlockMockRecorder) WasRetrievedFromDisk() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WasRetrievedFromDisk", reflect.TypeOf((*MockDatabaseBlock)(nil).WasRetrievedFromDisk))
}

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

// IsCachedBlock indicates an expected call of IsCachedBlock
func (mr *MockDatabaseBlockMockRecorder) IsCachedBlock() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCachedBlock", reflect.TypeOf((*MockDatabaseBlock)(nil).IsCachedBlock))
}

// Reset mocks base method
func (m *MockDatabaseBlock) Reset(startTime time.Time, blockSize time.Duration, segment ts.Segment) {
	m.ctrl.Call(m, "Reset", startTime, blockSize, segment)
}

// Reset indicates an expected call of Reset
func (mr *MockDatabaseBlockMockRecorder) Reset(startTime, blockSize, segment interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockDatabaseBlock)(nil).Reset), startTime, blockSize, segment)
}

// ResetRetrievable mocks base method
func (m *MockDatabaseBlock) ResetRetrievable(startTime time.Time, blockSize time.Duration, retriever DatabaseShardBlockRetriever, metadata RetrievableBlockMetadata) {
	m.ctrl.Call(m, "ResetRetrievable", startTime, blockSize, retriever, metadata)
}

// ResetRetrievable indicates an expected call of ResetRetrievable
func (mr *MockDatabaseBlockMockRecorder) ResetRetrievable(startTime, blockSize, retriever, metadata interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetRetrievable", reflect.TypeOf((*MockDatabaseBlock)(nil).ResetRetrievable), startTime, blockSize, retriever, metadata)
}

// Discard mocks base method
func (m *MockDatabaseBlock) Discard() ts.Segment {
	ret := m.ctrl.Call(m, "Discard")
	ret0, _ := ret[0].(ts.Segment)
	return ret0
}

// Discard indicates an expected call of Discard
func (mr *MockDatabaseBlockMockRecorder) Discard() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDatabaseBlock)(nil).Discard))
}

// Close mocks base method
func (m *MockDatabaseBlock) Close() {
	m.ctrl.Call(m, "Close")
}

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

// SetOnEvictedFromWiredList mocks base method
func (m *MockDatabaseBlock) SetOnEvictedFromWiredList(arg0 OnEvictedFromWiredList) {
	m.ctrl.Call(m, "SetOnEvictedFromWiredList", arg0)
}

// SetOnEvictedFromWiredList indicates an expected call of SetOnEvictedFromWiredList
func (mr *MockDatabaseBlockMockRecorder) SetOnEvictedFromWiredList(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOnEvictedFromWiredList", reflect.TypeOf((*MockDatabaseBlock)(nil).SetOnEvictedFromWiredList), arg0)
}

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

// OnEvictedFromWiredList indicates an expected call of OnEvictedFromWiredList
func (mr *MockDatabaseBlockMockRecorder) OnEvictedFromWiredList() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEvictedFromWiredList", reflect.TypeOf((*MockDatabaseBlock)(nil).OnEvictedFromWiredList))
}

// next mocks base method
func (m *MockDatabaseBlock) next() DatabaseBlock {
	ret := m.ctrl.Call(m, "next")
	ret0, _ := ret[0].(DatabaseBlock)
	return ret0
}

// next indicates an expected call of next
func (mr *MockDatabaseBlockMockRecorder) next() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "next", reflect.TypeOf((*MockDatabaseBlock)(nil).next))
}

// setNext mocks base method
func (m *MockDatabaseBlock) setNext(block DatabaseBlock) {
	m.ctrl.Call(m, "setNext", block)
}

// setNext indicates an expected call of setNext
func (mr *MockDatabaseBlockMockRecorder) setNext(block interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setNext", reflect.TypeOf((*MockDatabaseBlock)(nil).setNext), block)
}

// prev mocks base method
func (m *MockDatabaseBlock) prev() DatabaseBlock {
	ret := m.ctrl.Call(m, "prev")
	ret0, _ := ret[0].(DatabaseBlock)
	return ret0
}

// prev indicates an expected call of prev
func (mr *MockDatabaseBlockMockRecorder) prev() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "prev", reflect.TypeOf((*MockDatabaseBlock)(nil).prev))
}

// setPrev mocks base method
func (m *MockDatabaseBlock) setPrev(block DatabaseBlock) {
	m.ctrl.Call(m, "setPrev", block)
}

// setPrev indicates an expected call of setPrev
func (mr *MockDatabaseBlockMockRecorder) setPrev(block interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setPrev", reflect.TypeOf((*MockDatabaseBlock)(nil).setPrev), block)
}

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

// nextPrevUpdatedAtUnixNano indicates an expected call of nextPrevUpdatedAtUnixNano
func (mr *MockDatabaseBlockMockRecorder) nextPrevUpdatedAtUnixNano() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "nextPrevUpdatedAtUnixNano", reflect.TypeOf((*MockDatabaseBlock)(nil).nextPrevUpdatedAtUnixNano))
}

// setNextPrevUpdatedAtUnixNano mocks base method
func (m *MockDatabaseBlock) setNextPrevUpdatedAtUnixNano(value int64) {
	m.ctrl.Call(m, "setNextPrevUpdatedAtUnixNano", value)
}

// setNextPrevUpdatedAtUnixNano indicates an expected call of setNextPrevUpdatedAtUnixNano
func (mr *MockDatabaseBlockMockRecorder) setNextPrevUpdatedAtUnixNano(value interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setNextPrevUpdatedAtUnixNano", reflect.TypeOf((*MockDatabaseBlock)(nil).setNextPrevUpdatedAtUnixNano), value)
}

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

// wiredListEntry indicates an expected call of wiredListEntry
func (mr *MockDatabaseBlockMockRecorder) wiredListEntry() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "wiredListEntry", reflect.TypeOf((*MockDatabaseBlock)(nil).wiredListEntry))
}

// MockdatabaseBlock is a mock of databaseBlock interface
type MockdatabaseBlock struct {
	ctrl     *gomock.Controller
	recorder *MockdatabaseBlockMockRecorder
}

// MockdatabaseBlockMockRecorder is the mock recorder for MockdatabaseBlock
type MockdatabaseBlockMockRecorder struct {
	mock *MockdatabaseBlock
}

// NewMockdatabaseBlock creates a new mock instance
func NewMockdatabaseBlock(ctrl *gomock.Controller) *MockdatabaseBlock {
	mock := &MockdatabaseBlock{ctrl: ctrl}
	mock.recorder = &MockdatabaseBlockMockRecorder{mock}
	return mock
}

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

// next mocks base method
func (m *MockdatabaseBlock) next() DatabaseBlock {
	ret := m.ctrl.Call(m, "next")
	ret0, _ := ret[0].(DatabaseBlock)
	return ret0
}

// next indicates an expected call of next
func (mr *MockdatabaseBlockMockRecorder) next() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "next", reflect.TypeOf((*MockdatabaseBlock)(nil).next))
}

// setNext mocks base method
func (m *MockdatabaseBlock) setNext(block DatabaseBlock) {
	m.ctrl.Call(m, "setNext", block)
}

// setNext indicates an expected call of setNext
func (mr *MockdatabaseBlockMockRecorder) setNext(block interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setNext", reflect.TypeOf((*MockdatabaseBlock)(nil).setNext), block)
}

// prev mocks base method
func (m *MockdatabaseBlock) prev() DatabaseBlock {
	ret := m.ctrl.Call(m, "prev")
	ret0, _ := ret[0].(DatabaseBlock)
	return ret0
}

// prev indicates an expected call of prev
func (mr *MockdatabaseBlockMockRecorder) prev() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "prev", reflect.TypeOf((*MockdatabaseBlock)(nil).prev))
}

// setPrev mocks base method
func (m *MockdatabaseBlock) setPrev(block DatabaseBlock) {
	m.ctrl.Call(m, "setPrev", block)
}

// setPrev indicates an expected call of setPrev
func (mr *MockdatabaseBlockMockRecorder) setPrev(block interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setPrev", reflect.TypeOf((*MockdatabaseBlock)(nil).setPrev), block)
}

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

// nextPrevUpdatedAtUnixNano indicates an expected call of nextPrevUpdatedAtUnixNano
func (mr *MockdatabaseBlockMockRecorder) nextPrevUpdatedAtUnixNano() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "nextPrevUpdatedAtUnixNano", reflect.TypeOf((*MockdatabaseBlock)(nil).nextPrevUpdatedAtUnixNano))
}

// setNextPrevUpdatedAtUnixNano mocks base method
func (m *MockdatabaseBlock) setNextPrevUpdatedAtUnixNano(value int64) {
	m.ctrl.Call(m, "setNextPrevUpdatedAtUnixNano", value)
}

// setNextPrevUpdatedAtUnixNano indicates an expected call of setNextPrevUpdatedAtUnixNano
func (mr *MockdatabaseBlockMockRecorder) setNextPrevUpdatedAtUnixNano(value interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setNextPrevUpdatedAtUnixNano", reflect.TypeOf((*MockdatabaseBlock)(nil).setNextPrevUpdatedAtUnixNano), value)
}

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

// wiredListEntry indicates an expected call of wiredListEntry
func (mr *MockdatabaseBlockMockRecorder) wiredListEntry() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "wiredListEntry", reflect.TypeOf((*MockdatabaseBlock)(nil).wiredListEntry))
}

// MockOnEvictedFromWiredList is a mock of OnEvictedFromWiredList interface
type MockOnEvictedFromWiredList struct {
	ctrl     *gomock.Controller
	recorder *MockOnEvictedFromWiredListMockRecorder
}

// MockOnEvictedFromWiredListMockRecorder is the mock recorder for MockOnEvictedFromWiredList
type MockOnEvictedFromWiredListMockRecorder struct {
	mock *MockOnEvictedFromWiredList
}

// NewMockOnEvictedFromWiredList creates a new mock instance
func NewMockOnEvictedFromWiredList(ctrl *gomock.Controller) *MockOnEvictedFromWiredList {
	mock := &MockOnEvictedFromWiredList{ctrl: ctrl}
	mock.recorder = &MockOnEvictedFromWiredListMockRecorder{mock}
	return mock
}

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

// OnEvictedFromWiredList mocks base method
func (m *MockOnEvictedFromWiredList) OnEvictedFromWiredList(id ident.ID, blockStart time.Time) {
	m.ctrl.Call(m, "OnEvictedFromWiredList", id, blockStart)
}

// OnEvictedFromWiredList indicates an expected call of OnEvictedFromWiredList
func (mr *MockOnEvictedFromWiredListMockRecorder) OnEvictedFromWiredList(id, blockStart interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEvictedFromWiredList", reflect.TypeOf((*MockOnEvictedFromWiredList)(nil).OnEvictedFromWiredList), id, blockStart)
}

// MockOnRetrieveBlock is a mock of OnRetrieveBlock interface
type MockOnRetrieveBlock struct {
	ctrl     *gomock.Controller
	recorder *MockOnRetrieveBlockMockRecorder
}

// MockOnRetrieveBlockMockRecorder is the mock recorder for MockOnRetrieveBlock
type MockOnRetrieveBlockMockRecorder struct {
	mock *MockOnRetrieveBlock
}

// NewMockOnRetrieveBlock creates a new mock instance
func NewMockOnRetrieveBlock(ctrl *gomock.Controller) *MockOnRetrieveBlock {
	mock := &MockOnRetrieveBlock{ctrl: ctrl}
	mock.recorder = &MockOnRetrieveBlockMockRecorder{mock}
	return mock
}

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

// OnRetrieveBlock mocks base method
func (m *MockOnRetrieveBlock) OnRetrieveBlock(id ident.ID, tags ident.TagIterator, startTime time.Time, segment ts.Segment) {
	m.ctrl.Call(m, "OnRetrieveBlock", id, tags, startTime, segment)
}

// OnRetrieveBlock indicates an expected call of OnRetrieveBlock
func (mr *MockOnRetrieveBlockMockRecorder) OnRetrieveBlock(id, tags, startTime, segment interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetrieveBlock", reflect.TypeOf((*MockOnRetrieveBlock)(nil).OnRetrieveBlock), id, tags, startTime, segment)
}

// MockOnReadBlock is a mock of OnReadBlock interface
type MockOnReadBlock struct {
	ctrl     *gomock.Controller
	recorder *MockOnReadBlockMockRecorder
}

// MockOnReadBlockMockRecorder is the mock recorder for MockOnReadBlock
type MockOnReadBlockMockRecorder struct {
	mock *MockOnReadBlock
}

// NewMockOnReadBlock creates a new mock instance
func NewMockOnReadBlock(ctrl *gomock.Controller) *MockOnReadBlock {
	mock := &MockOnReadBlock{ctrl: ctrl}
	mock.recorder = &MockOnReadBlockMockRecorder{mock}
	return mock
}

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

// OnReadBlock mocks base method
func (m *MockOnReadBlock) OnReadBlock(b DatabaseBlock) {
	m.ctrl.Call(m, "OnReadBlock", b)
}

// OnReadBlock indicates an expected call of OnReadBlock
func (mr *MockOnReadBlockMockRecorder) OnReadBlock(b interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnReadBlock", reflect.TypeOf((*MockOnReadBlock)(nil).OnReadBlock), b)
}

// MockDatabaseBlockRetriever is a mock of DatabaseBlockRetriever interface
type MockDatabaseBlockRetriever struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockRetrieverMockRecorder
}

// MockDatabaseBlockRetrieverMockRecorder is the mock recorder for MockDatabaseBlockRetriever
type MockDatabaseBlockRetrieverMockRecorder struct {
	mock *MockDatabaseBlockRetriever
}

// NewMockDatabaseBlockRetriever creates a new mock instance
func NewMockDatabaseBlockRetriever(ctrl *gomock.Controller) *MockDatabaseBlockRetriever {
	mock := &MockDatabaseBlockRetriever{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockRetrieverMockRecorder{mock}
	return mock
}

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

// CacheShardIndices mocks base method
func (m *MockDatabaseBlockRetriever) CacheShardIndices(shards []uint32) error {
	ret := m.ctrl.Call(m, "CacheShardIndices", shards)
	ret0, _ := ret[0].(error)
	return ret0
}

// CacheShardIndices indicates an expected call of CacheShardIndices
func (mr *MockDatabaseBlockRetrieverMockRecorder) CacheShardIndices(shards interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CacheShardIndices", reflect.TypeOf((*MockDatabaseBlockRetriever)(nil).CacheShardIndices), shards)
}

// Stream mocks base method
func (m *MockDatabaseBlockRetriever) Stream(ctx context.Context, shard uint32, id ident.ID, blockStart time.Time, onRetrieve OnRetrieveBlock) (xio.BlockReader, error) {
	ret := m.ctrl.Call(m, "Stream", ctx, shard, id, blockStart, onRetrieve)
	ret0, _ := ret[0].(xio.BlockReader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stream indicates an expected call of Stream
func (mr *MockDatabaseBlockRetrieverMockRecorder) Stream(ctx, shard, id, blockStart, onRetrieve interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDatabaseBlockRetriever)(nil).Stream), ctx, shard, id, blockStart, onRetrieve)
}

// MockDatabaseShardBlockRetriever is a mock of DatabaseShardBlockRetriever interface
type MockDatabaseShardBlockRetriever struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseShardBlockRetrieverMockRecorder
}

// MockDatabaseShardBlockRetrieverMockRecorder is the mock recorder for MockDatabaseShardBlockRetriever
type MockDatabaseShardBlockRetrieverMockRecorder struct {
	mock *MockDatabaseShardBlockRetriever
}

// NewMockDatabaseShardBlockRetriever creates a new mock instance
func NewMockDatabaseShardBlockRetriever(ctrl *gomock.Controller) *MockDatabaseShardBlockRetriever {
	mock := &MockDatabaseShardBlockRetriever{ctrl: ctrl}
	mock.recorder = &MockDatabaseShardBlockRetrieverMockRecorder{mock}
	return mock
}

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

// Stream mocks base method
func (m *MockDatabaseShardBlockRetriever) Stream(ctx context.Context, id ident.ID, blockStart time.Time, onRetrieve OnRetrieveBlock) (xio.BlockReader, error) {
	ret := m.ctrl.Call(m, "Stream", ctx, id, blockStart, onRetrieve)
	ret0, _ := ret[0].(xio.BlockReader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stream indicates an expected call of Stream
func (mr *MockDatabaseShardBlockRetrieverMockRecorder) Stream(ctx, id, blockStart, onRetrieve interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDatabaseShardBlockRetriever)(nil).Stream), ctx, id, blockStart, onRetrieve)
}

// MockDatabaseBlockRetrieverManager is a mock of DatabaseBlockRetrieverManager interface
type MockDatabaseBlockRetrieverManager struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockRetrieverManagerMockRecorder
}

// MockDatabaseBlockRetrieverManagerMockRecorder is the mock recorder for MockDatabaseBlockRetrieverManager
type MockDatabaseBlockRetrieverManagerMockRecorder struct {
	mock *MockDatabaseBlockRetrieverManager
}

// NewMockDatabaseBlockRetrieverManager creates a new mock instance
func NewMockDatabaseBlockRetrieverManager(ctrl *gomock.Controller) *MockDatabaseBlockRetrieverManager {
	mock := &MockDatabaseBlockRetrieverManager{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockRetrieverManagerMockRecorder{mock}
	return mock
}

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

// Retriever mocks base method
func (m *MockDatabaseBlockRetrieverManager) Retriever(nsMetadata namespace.Metadata) (DatabaseBlockRetriever, error) {
	ret := m.ctrl.Call(m, "Retriever", nsMetadata)
	ret0, _ := ret[0].(DatabaseBlockRetriever)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Retriever indicates an expected call of Retriever
func (mr *MockDatabaseBlockRetrieverManagerMockRecorder) Retriever(nsMetadata interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retriever", reflect.TypeOf((*MockDatabaseBlockRetrieverManager)(nil).Retriever), nsMetadata)
}

// MockDatabaseShardBlockRetrieverManager is a mock of DatabaseShardBlockRetrieverManager interface
type MockDatabaseShardBlockRetrieverManager struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseShardBlockRetrieverManagerMockRecorder
}

// MockDatabaseShardBlockRetrieverManagerMockRecorder is the mock recorder for MockDatabaseShardBlockRetrieverManager
type MockDatabaseShardBlockRetrieverManagerMockRecorder struct {
	mock *MockDatabaseShardBlockRetrieverManager
}

// NewMockDatabaseShardBlockRetrieverManager creates a new mock instance
func NewMockDatabaseShardBlockRetrieverManager(ctrl *gomock.Controller) *MockDatabaseShardBlockRetrieverManager {
	mock := &MockDatabaseShardBlockRetrieverManager{ctrl: ctrl}
	mock.recorder = &MockDatabaseShardBlockRetrieverManagerMockRecorder{mock}
	return mock
}

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

// ShardRetriever mocks base method
func (m *MockDatabaseShardBlockRetrieverManager) ShardRetriever(shard uint32) DatabaseShardBlockRetriever {
	ret := m.ctrl.Call(m, "ShardRetriever", shard)
	ret0, _ := ret[0].(DatabaseShardBlockRetriever)
	return ret0
}

// ShardRetriever indicates an expected call of ShardRetriever
func (mr *MockDatabaseShardBlockRetrieverManagerMockRecorder) ShardRetriever(shard interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShardRetriever", reflect.TypeOf((*MockDatabaseShardBlockRetrieverManager)(nil).ShardRetriever), shard)
}

// MockDatabaseSeriesBlocks is a mock of DatabaseSeriesBlocks interface
type MockDatabaseSeriesBlocks struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseSeriesBlocksMockRecorder
}

// MockDatabaseSeriesBlocksMockRecorder is the mock recorder for MockDatabaseSeriesBlocks
type MockDatabaseSeriesBlocksMockRecorder struct {
	mock *MockDatabaseSeriesBlocks
}

// NewMockDatabaseSeriesBlocks creates a new mock instance
func NewMockDatabaseSeriesBlocks(ctrl *gomock.Controller) *MockDatabaseSeriesBlocks {
	mock := &MockDatabaseSeriesBlocks{ctrl: ctrl}
	mock.recorder = &MockDatabaseSeriesBlocksMockRecorder{mock}
	return mock
}

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

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

// Len indicates an expected call of Len
func (mr *MockDatabaseSeriesBlocksMockRecorder) Len() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).Len))
}

// AddBlock mocks base method
func (m *MockDatabaseSeriesBlocks) AddBlock(block DatabaseBlock) {
	m.ctrl.Call(m, "AddBlock", block)
}

// AddBlock indicates an expected call of AddBlock
func (mr *MockDatabaseSeriesBlocksMockRecorder) AddBlock(block interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).AddBlock), block)
}

// AddSeries mocks base method
func (m *MockDatabaseSeriesBlocks) AddSeries(other DatabaseSeriesBlocks) {
	m.ctrl.Call(m, "AddSeries", other)
}

// AddSeries indicates an expected call of AddSeries
func (mr *MockDatabaseSeriesBlocksMockRecorder) AddSeries(other interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSeries", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).AddSeries), other)
}

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

// MinTime indicates an expected call of MinTime
func (mr *MockDatabaseSeriesBlocksMockRecorder) MinTime() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MinTime", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).MinTime))
}

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

// MaxTime indicates an expected call of MaxTime
func (mr *MockDatabaseSeriesBlocksMockRecorder) MaxTime() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxTime", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).MaxTime))
}

// BlockAt mocks base method
func (m *MockDatabaseSeriesBlocks) BlockAt(t time.Time) (DatabaseBlock, bool) {
	ret := m.ctrl.Call(m, "BlockAt", t)
	ret0, _ := ret[0].(DatabaseBlock)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// BlockAt indicates an expected call of BlockAt
func (mr *MockDatabaseSeriesBlocksMockRecorder) BlockAt(t interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockAt", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).BlockAt), t)
}

// AllBlocks mocks base method
func (m *MockDatabaseSeriesBlocks) AllBlocks() map[time0.UnixNano]DatabaseBlock {
	ret := m.ctrl.Call(m, "AllBlocks")
	ret0, _ := ret[0].(map[time0.UnixNano]DatabaseBlock)
	return ret0
}

// AllBlocks indicates an expected call of AllBlocks
func (mr *MockDatabaseSeriesBlocksMockRecorder) AllBlocks() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllBlocks", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).AllBlocks))
}

// RemoveBlockAt mocks base method
func (m *MockDatabaseSeriesBlocks) RemoveBlockAt(t time.Time) {
	m.ctrl.Call(m, "RemoveBlockAt", t)
}

// RemoveBlockAt indicates an expected call of RemoveBlockAt
func (mr *MockDatabaseSeriesBlocksMockRecorder) RemoveBlockAt(t interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBlockAt", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).RemoveBlockAt), t)
}

// RemoveAll mocks base method
func (m *MockDatabaseSeriesBlocks) RemoveAll() {
	m.ctrl.Call(m, "RemoveAll")
}

// RemoveAll indicates an expected call of RemoveAll
func (mr *MockDatabaseSeriesBlocksMockRecorder) RemoveAll() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).RemoveAll))
}

// Reset mocks base method
func (m *MockDatabaseSeriesBlocks) Reset() {
	m.ctrl.Call(m, "Reset")
}

// Reset indicates an expected call of Reset
func (mr *MockDatabaseSeriesBlocksMockRecorder) Reset() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).Reset))
}

// Close mocks base method
func (m *MockDatabaseSeriesBlocks) Close() {
	m.ctrl.Call(m, "Close")
}

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

// MockDatabaseBlockPool is a mock of DatabaseBlockPool interface
type MockDatabaseBlockPool struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockPoolMockRecorder
}

// MockDatabaseBlockPoolMockRecorder is the mock recorder for MockDatabaseBlockPool
type MockDatabaseBlockPoolMockRecorder struct {
	mock *MockDatabaseBlockPool
}

// NewMockDatabaseBlockPool creates a new mock instance
func NewMockDatabaseBlockPool(ctrl *gomock.Controller) *MockDatabaseBlockPool {
	mock := &MockDatabaseBlockPool{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockPoolMockRecorder{mock}
	return mock
}

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

// Init mocks base method
func (m *MockDatabaseBlockPool) Init(alloc DatabaseBlockAllocate) {
	m.ctrl.Call(m, "Init", alloc)
}

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

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

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

// Put mocks base method
func (m *MockDatabaseBlockPool) Put(block DatabaseBlock) {
	m.ctrl.Call(m, "Put", block)
}

// Put indicates an expected call of Put
func (mr *MockDatabaseBlockPoolMockRecorder) Put(block interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockDatabaseBlockPool)(nil).Put), block)
}

// MockFetchBlockMetadataResultsPool is a mock of FetchBlockMetadataResultsPool interface
type MockFetchBlockMetadataResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlockMetadataResultsPoolMockRecorder
}

// MockFetchBlockMetadataResultsPoolMockRecorder is the mock recorder for MockFetchBlockMetadataResultsPool
type MockFetchBlockMetadataResultsPoolMockRecorder struct {
	mock *MockFetchBlockMetadataResultsPool
}

// NewMockFetchBlockMetadataResultsPool creates a new mock instance
func NewMockFetchBlockMetadataResultsPool(ctrl *gomock.Controller) *MockFetchBlockMetadataResultsPool {
	mock := &MockFetchBlockMetadataResultsPool{ctrl: ctrl}
	mock.recorder = &MockFetchBlockMetadataResultsPoolMockRecorder{mock}
	return mock
}

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

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

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

// Put mocks base method
func (m *MockFetchBlockMetadataResultsPool) Put(res FetchBlockMetadataResults) {
	m.ctrl.Call(m, "Put", res)
}

// Put indicates an expected call of Put
func (mr *MockFetchBlockMetadataResultsPoolMockRecorder) Put(res interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockFetchBlockMetadataResultsPool)(nil).Put), res)
}

// MockFetchBlocksMetadataResultsPool is a mock of FetchBlocksMetadataResultsPool interface
type MockFetchBlocksMetadataResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlocksMetadataResultsPoolMockRecorder
}

// MockFetchBlocksMetadataResultsPoolMockRecorder is the mock recorder for MockFetchBlocksMetadataResultsPool
type MockFetchBlocksMetadataResultsPoolMockRecorder struct {
	mock *MockFetchBlocksMetadataResultsPool
}

// NewMockFetchBlocksMetadataResultsPool creates a new mock instance
func NewMockFetchBlocksMetadataResultsPool(ctrl *gomock.Controller) *MockFetchBlocksMetadataResultsPool {
	mock := &MockFetchBlocksMetadataResultsPool{ctrl: ctrl}
	mock.recorder = &MockFetchBlocksMetadataResultsPoolMockRecorder{mock}
	return mock
}

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

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

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

// Put mocks base method
func (m *MockFetchBlocksMetadataResultsPool) Put(res FetchBlocksMetadataResults) {
	m.ctrl.Call(m, "Put", res)
}

// Put indicates an expected call of Put
func (mr *MockFetchBlocksMetadataResultsPoolMockRecorder) Put(res interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockFetchBlocksMetadataResultsPool)(nil).Put), res)
}

// 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
}

// SetClockOptions mocks base method
func (m *MockOptions) SetClockOptions(value clock.Options) Options {
	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 {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetClockOptions", reflect.TypeOf((*MockOptions)(nil).SetClockOptions), value)
}

// ClockOptions mocks base method
func (m *MockOptions) ClockOptions() clock.Options {
	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 {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClockOptions", reflect.TypeOf((*MockOptions)(nil).ClockOptions))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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