memory.cosmos_orm.go

// Code generated by protoc-gen-go-cosmos-orm. DO NOT EDIT.

package orderbookv1alpha1

import (
	context "context"
	ormlist "github.com/cosmos/cosmos-sdk/orm/model/ormlist"
	ormtable "github.com/cosmos/cosmos-sdk/orm/model/ormtable"
	ormerrors "github.com/cosmos/cosmos-sdk/orm/types/ormerrors"
)

type BuyOrderSellOrderMatchTable interface {
	Insert(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error
	Update(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error
	Save(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error
	Delete(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error
	Has(ctx context.Context, buy_order_id uint64, sell_order_id uint64) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, buy_order_id uint64, sell_order_id uint64) (*BuyOrderSellOrderMatch, error)
	List(ctx context.Context, prefixKey BuyOrderSellOrderMatchIndexKey, opts ...ormlist.Option) (BuyOrderSellOrderMatchIterator, error)
	ListRange(ctx context.Context, from, to BuyOrderSellOrderMatchIndexKey, opts ...ormlist.Option) (BuyOrderSellOrderMatchIterator, error)
	DeleteBy(ctx context.Context, prefixKey BuyOrderSellOrderMatchIndexKey) error
	DeleteRange(ctx context.Context, from, to BuyOrderSellOrderMatchIndexKey) error

	doNotImplement()
}

type BuyOrderSellOrderMatchIterator struct {
	ormtable.Iterator
}

func (i BuyOrderSellOrderMatchIterator) Value() (*BuyOrderSellOrderMatch, error) {
	var buyOrderSellOrderMatch BuyOrderSellOrderMatch
	err := i.UnmarshalMessage(&buyOrderSellOrderMatch)
	return &buyOrderSellOrderMatch, err
}

type BuyOrderSellOrderMatchIndexKey interface {
	id() uint32
	values() []interface{}
	buyOrderSellOrderMatchIndexKey()
}

// primary key starting index..
type BuyOrderSellOrderMatchPrimaryKey = BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey

type BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey) id() uint32                      { return 0 }
func (x BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey) values() []interface{}           { return x.vs }
func (x BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey) buyOrderSellOrderMatchIndexKey() {}

func (this BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey) WithBuyOrderId(buy_order_id uint64) BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey {
	this.vs = []interface{}{buy_order_id}
	return this
}

func (this BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey) WithBuyOrderIdSellOrderId(buy_order_id uint64, sell_order_id uint64) BuyOrderSellOrderMatchBuyOrderIdSellOrderIdIndexKey {
	this.vs = []interface{}{buy_order_id, sell_order_id}
	return this
}

type BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) id() uint32 {
	return 1
}
func (x BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) values() []interface{} {
	return x.vs
}
func (x BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) buyOrderSellOrderMatchIndexKey() {
}

func (this BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) WithMarketId(market_id uint64) BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey {
	this.vs = []interface{}{market_id}
	return this
}

func (this BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) WithMarketIdBidPriceComplement(market_id uint64, bid_price_complement uint32) BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey {
	this.vs = []interface{}{market_id, bid_price_complement}
	return this
}

func (this BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) WithMarketIdBidPriceComplementBuyOrderId(market_id uint64, bid_price_complement uint32, buy_order_id uint64) BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey {
	this.vs = []interface{}{market_id, bid_price_complement, buy_order_id}
	return this
}

func (this BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) WithMarketIdBidPriceComplementBuyOrderIdAskPrice(market_id uint64, bid_price_complement uint32, buy_order_id uint64, ask_price uint32) BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey {
	this.vs = []interface{}{market_id, bid_price_complement, buy_order_id, ask_price}
	return this
}

func (this BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey) WithMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderId(market_id uint64, bid_price_complement uint32, buy_order_id uint64, ask_price uint32, sell_order_id uint64) BuyOrderSellOrderMatchMarketIdBidPriceComplementBuyOrderIdAskPriceSellOrderIdIndexKey {
	this.vs = []interface{}{market_id, bid_price_complement, buy_order_id, ask_price, sell_order_id}
	return this
}

type BuyOrderSellOrderMatchSellOrderIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderSellOrderMatchSellOrderIdIndexKey) id() uint32                      { return 2 }
func (x BuyOrderSellOrderMatchSellOrderIdIndexKey) values() []interface{}           { return x.vs }
func (x BuyOrderSellOrderMatchSellOrderIdIndexKey) buyOrderSellOrderMatchIndexKey() {}

func (this BuyOrderSellOrderMatchSellOrderIdIndexKey) WithSellOrderId(sell_order_id uint64) BuyOrderSellOrderMatchSellOrderIdIndexKey {
	this.vs = []interface{}{sell_order_id}
	return this
}

type buyOrderSellOrderMatchTable struct {
	table ormtable.Table
}

func (this buyOrderSellOrderMatchTable) Insert(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error {
	return this.table.Insert(ctx, buyOrderSellOrderMatch)
}

func (this buyOrderSellOrderMatchTable) Update(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error {
	return this.table.Update(ctx, buyOrderSellOrderMatch)
}

func (this buyOrderSellOrderMatchTable) Save(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error {
	return this.table.Save(ctx, buyOrderSellOrderMatch)
}

func (this buyOrderSellOrderMatchTable) Delete(ctx context.Context, buyOrderSellOrderMatch *BuyOrderSellOrderMatch) error {
	return this.table.Delete(ctx, buyOrderSellOrderMatch)
}

func (this buyOrderSellOrderMatchTable) Has(ctx context.Context, buy_order_id uint64, sell_order_id uint64) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, buy_order_id, sell_order_id)
}

func (this buyOrderSellOrderMatchTable) Get(ctx context.Context, buy_order_id uint64, sell_order_id uint64) (*BuyOrderSellOrderMatch, error) {
	var buyOrderSellOrderMatch BuyOrderSellOrderMatch
	found, err := this.table.PrimaryKey().Get(ctx, &buyOrderSellOrderMatch, buy_order_id, sell_order_id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &buyOrderSellOrderMatch, nil
}

func (this buyOrderSellOrderMatchTable) List(ctx context.Context, prefixKey BuyOrderSellOrderMatchIndexKey, opts ...ormlist.Option) (BuyOrderSellOrderMatchIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return BuyOrderSellOrderMatchIterator{it}, err
}

func (this buyOrderSellOrderMatchTable) ListRange(ctx context.Context, from, to BuyOrderSellOrderMatchIndexKey, opts ...ormlist.Option) (BuyOrderSellOrderMatchIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return BuyOrderSellOrderMatchIterator{it}, err
}

func (this buyOrderSellOrderMatchTable) DeleteBy(ctx context.Context, prefixKey BuyOrderSellOrderMatchIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this buyOrderSellOrderMatchTable) DeleteRange(ctx context.Context, from, to BuyOrderSellOrderMatchIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this buyOrderSellOrderMatchTable) doNotImplement() {}

var _ BuyOrderSellOrderMatchTable = buyOrderSellOrderMatchTable{}

func NewBuyOrderSellOrderMatchTable(db ormtable.Schema) (BuyOrderSellOrderMatchTable, error) {
	table := db.GetTable(&BuyOrderSellOrderMatch{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&BuyOrderSellOrderMatch{}).ProtoReflect().Descriptor().FullName()))
	}
	return buyOrderSellOrderMatchTable{table}, nil
}

type BuyOrderClassSelectorTable interface {
	Insert(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error
	Update(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error
	Save(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error
	Delete(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error
	Has(ctx context.Context, buy_order_id uint64, class_id uint64) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, buy_order_id uint64, class_id uint64) (*BuyOrderClassSelector, error)
	List(ctx context.Context, prefixKey BuyOrderClassSelectorIndexKey, opts ...ormlist.Option) (BuyOrderClassSelectorIterator, error)
	ListRange(ctx context.Context, from, to BuyOrderClassSelectorIndexKey, opts ...ormlist.Option) (BuyOrderClassSelectorIterator, error)
	DeleteBy(ctx context.Context, prefixKey BuyOrderClassSelectorIndexKey) error
	DeleteRange(ctx context.Context, from, to BuyOrderClassSelectorIndexKey) error

	doNotImplement()
}

type BuyOrderClassSelectorIterator struct {
	ormtable.Iterator
}

func (i BuyOrderClassSelectorIterator) Value() (*BuyOrderClassSelector, error) {
	var buyOrderClassSelector BuyOrderClassSelector
	err := i.UnmarshalMessage(&buyOrderClassSelector)
	return &buyOrderClassSelector, err
}

type BuyOrderClassSelectorIndexKey interface {
	id() uint32
	values() []interface{}
	buyOrderClassSelectorIndexKey()
}

// primary key starting index..
type BuyOrderClassSelectorPrimaryKey = BuyOrderClassSelectorBuyOrderIdClassIdIndexKey

type BuyOrderClassSelectorBuyOrderIdClassIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderClassSelectorBuyOrderIdClassIdIndexKey) id() uint32                     { return 0 }
func (x BuyOrderClassSelectorBuyOrderIdClassIdIndexKey) values() []interface{}          { return x.vs }
func (x BuyOrderClassSelectorBuyOrderIdClassIdIndexKey) buyOrderClassSelectorIndexKey() {}

func (this BuyOrderClassSelectorBuyOrderIdClassIdIndexKey) WithBuyOrderId(buy_order_id uint64) BuyOrderClassSelectorBuyOrderIdClassIdIndexKey {
	this.vs = []interface{}{buy_order_id}
	return this
}

func (this BuyOrderClassSelectorBuyOrderIdClassIdIndexKey) WithBuyOrderIdClassId(buy_order_id uint64, class_id uint64) BuyOrderClassSelectorBuyOrderIdClassIdIndexKey {
	this.vs = []interface{}{buy_order_id, class_id}
	return this
}

type BuyOrderClassSelectorClassIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderClassSelectorClassIdIndexKey) id() uint32                     { return 1 }
func (x BuyOrderClassSelectorClassIdIndexKey) values() []interface{}          { return x.vs }
func (x BuyOrderClassSelectorClassIdIndexKey) buyOrderClassSelectorIndexKey() {}

func (this BuyOrderClassSelectorClassIdIndexKey) WithClassId(class_id uint64) BuyOrderClassSelectorClassIdIndexKey {
	this.vs = []interface{}{class_id}
	return this
}

type buyOrderClassSelectorTable struct {
	table ormtable.Table
}

func (this buyOrderClassSelectorTable) Insert(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error {
	return this.table.Insert(ctx, buyOrderClassSelector)
}

func (this buyOrderClassSelectorTable) Update(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error {
	return this.table.Update(ctx, buyOrderClassSelector)
}

func (this buyOrderClassSelectorTable) Save(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error {
	return this.table.Save(ctx, buyOrderClassSelector)
}

func (this buyOrderClassSelectorTable) Delete(ctx context.Context, buyOrderClassSelector *BuyOrderClassSelector) error {
	return this.table.Delete(ctx, buyOrderClassSelector)
}

func (this buyOrderClassSelectorTable) Has(ctx context.Context, buy_order_id uint64, class_id uint64) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, buy_order_id, class_id)
}

func (this buyOrderClassSelectorTable) Get(ctx context.Context, buy_order_id uint64, class_id uint64) (*BuyOrderClassSelector, error) {
	var buyOrderClassSelector BuyOrderClassSelector
	found, err := this.table.PrimaryKey().Get(ctx, &buyOrderClassSelector, buy_order_id, class_id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &buyOrderClassSelector, nil
}

func (this buyOrderClassSelectorTable) List(ctx context.Context, prefixKey BuyOrderClassSelectorIndexKey, opts ...ormlist.Option) (BuyOrderClassSelectorIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return BuyOrderClassSelectorIterator{it}, err
}

func (this buyOrderClassSelectorTable) ListRange(ctx context.Context, from, to BuyOrderClassSelectorIndexKey, opts ...ormlist.Option) (BuyOrderClassSelectorIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return BuyOrderClassSelectorIterator{it}, err
}

func (this buyOrderClassSelectorTable) DeleteBy(ctx context.Context, prefixKey BuyOrderClassSelectorIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this buyOrderClassSelectorTable) DeleteRange(ctx context.Context, from, to BuyOrderClassSelectorIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this buyOrderClassSelectorTable) doNotImplement() {}

var _ BuyOrderClassSelectorTable = buyOrderClassSelectorTable{}

func NewBuyOrderClassSelectorTable(db ormtable.Schema) (BuyOrderClassSelectorTable, error) {
	table := db.GetTable(&BuyOrderClassSelector{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&BuyOrderClassSelector{}).ProtoReflect().Descriptor().FullName()))
	}
	return buyOrderClassSelectorTable{table}, nil
}

type BuyOrderProjectSelectorTable interface {
	Insert(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error
	Update(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error
	Save(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error
	Delete(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error
	Has(ctx context.Context, buy_order_id uint64, project_id uint64) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, buy_order_id uint64, project_id uint64) (*BuyOrderProjectSelector, error)
	List(ctx context.Context, prefixKey BuyOrderProjectSelectorIndexKey, opts ...ormlist.Option) (BuyOrderProjectSelectorIterator, error)
	ListRange(ctx context.Context, from, to BuyOrderProjectSelectorIndexKey, opts ...ormlist.Option) (BuyOrderProjectSelectorIterator, error)
	DeleteBy(ctx context.Context, prefixKey BuyOrderProjectSelectorIndexKey) error
	DeleteRange(ctx context.Context, from, to BuyOrderProjectSelectorIndexKey) error

	doNotImplement()
}

type BuyOrderProjectSelectorIterator struct {
	ormtable.Iterator
}

func (i BuyOrderProjectSelectorIterator) Value() (*BuyOrderProjectSelector, error) {
	var buyOrderProjectSelector BuyOrderProjectSelector
	err := i.UnmarshalMessage(&buyOrderProjectSelector)
	return &buyOrderProjectSelector, err
}

type BuyOrderProjectSelectorIndexKey interface {
	id() uint32
	values() []interface{}
	buyOrderProjectSelectorIndexKey()
}

// primary key starting index..
type BuyOrderProjectSelectorPrimaryKey = BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey

type BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey) id() uint32                       { return 0 }
func (x BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey) values() []interface{}            { return x.vs }
func (x BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey) buyOrderProjectSelectorIndexKey() {}

func (this BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey) WithBuyOrderId(buy_order_id uint64) BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey {
	this.vs = []interface{}{buy_order_id}
	return this
}

func (this BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey) WithBuyOrderIdProjectId(buy_order_id uint64, project_id uint64) BuyOrderProjectSelectorBuyOrderIdProjectIdIndexKey {
	this.vs = []interface{}{buy_order_id, project_id}
	return this
}

type BuyOrderProjectSelectorProjectIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderProjectSelectorProjectIdIndexKey) id() uint32                       { return 1 }
func (x BuyOrderProjectSelectorProjectIdIndexKey) values() []interface{}            { return x.vs }
func (x BuyOrderProjectSelectorProjectIdIndexKey) buyOrderProjectSelectorIndexKey() {}

func (this BuyOrderProjectSelectorProjectIdIndexKey) WithProjectId(project_id uint64) BuyOrderProjectSelectorProjectIdIndexKey {
	this.vs = []interface{}{project_id}
	return this
}

type buyOrderProjectSelectorTable struct {
	table ormtable.Table
}

func (this buyOrderProjectSelectorTable) Insert(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error {
	return this.table.Insert(ctx, buyOrderProjectSelector)
}

func (this buyOrderProjectSelectorTable) Update(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error {
	return this.table.Update(ctx, buyOrderProjectSelector)
}

func (this buyOrderProjectSelectorTable) Save(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error {
	return this.table.Save(ctx, buyOrderProjectSelector)
}

func (this buyOrderProjectSelectorTable) Delete(ctx context.Context, buyOrderProjectSelector *BuyOrderProjectSelector) error {
	return this.table.Delete(ctx, buyOrderProjectSelector)
}

func (this buyOrderProjectSelectorTable) Has(ctx context.Context, buy_order_id uint64, project_id uint64) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, buy_order_id, project_id)
}

func (this buyOrderProjectSelectorTable) Get(ctx context.Context, buy_order_id uint64, project_id uint64) (*BuyOrderProjectSelector, error) {
	var buyOrderProjectSelector BuyOrderProjectSelector
	found, err := this.table.PrimaryKey().Get(ctx, &buyOrderProjectSelector, buy_order_id, project_id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &buyOrderProjectSelector, nil
}

func (this buyOrderProjectSelectorTable) List(ctx context.Context, prefixKey BuyOrderProjectSelectorIndexKey, opts ...ormlist.Option) (BuyOrderProjectSelectorIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return BuyOrderProjectSelectorIterator{it}, err
}

func (this buyOrderProjectSelectorTable) ListRange(ctx context.Context, from, to BuyOrderProjectSelectorIndexKey, opts ...ormlist.Option) (BuyOrderProjectSelectorIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return BuyOrderProjectSelectorIterator{it}, err
}

func (this buyOrderProjectSelectorTable) DeleteBy(ctx context.Context, prefixKey BuyOrderProjectSelectorIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this buyOrderProjectSelectorTable) DeleteRange(ctx context.Context, from, to BuyOrderProjectSelectorIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this buyOrderProjectSelectorTable) doNotImplement() {}

var _ BuyOrderProjectSelectorTable = buyOrderProjectSelectorTable{}

func NewBuyOrderProjectSelectorTable(db ormtable.Schema) (BuyOrderProjectSelectorTable, error) {
	table := db.GetTable(&BuyOrderProjectSelector{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&BuyOrderProjectSelector{}).ProtoReflect().Descriptor().FullName()))
	}
	return buyOrderProjectSelectorTable{table}, nil
}

type BuyOrderBatchSelectorTable interface {
	Insert(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error
	Update(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error
	Save(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error
	Delete(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error
	Has(ctx context.Context, buy_order_id uint64, batch_id uint64) (found bool, err error)
	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	Get(ctx context.Context, buy_order_id uint64, batch_id uint64) (*BuyOrderBatchSelector, error)
	List(ctx context.Context, prefixKey BuyOrderBatchSelectorIndexKey, opts ...ormlist.Option) (BuyOrderBatchSelectorIterator, error)
	ListRange(ctx context.Context, from, to BuyOrderBatchSelectorIndexKey, opts ...ormlist.Option) (BuyOrderBatchSelectorIterator, error)
	DeleteBy(ctx context.Context, prefixKey BuyOrderBatchSelectorIndexKey) error
	DeleteRange(ctx context.Context, from, to BuyOrderBatchSelectorIndexKey) error

	doNotImplement()
}

type BuyOrderBatchSelectorIterator struct {
	ormtable.Iterator
}

func (i BuyOrderBatchSelectorIterator) Value() (*BuyOrderBatchSelector, error) {
	var buyOrderBatchSelector BuyOrderBatchSelector
	err := i.UnmarshalMessage(&buyOrderBatchSelector)
	return &buyOrderBatchSelector, err
}

type BuyOrderBatchSelectorIndexKey interface {
	id() uint32
	values() []interface{}
	buyOrderBatchSelectorIndexKey()
}

// primary key starting index..
type BuyOrderBatchSelectorPrimaryKey = BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey

type BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey) id() uint32                     { return 0 }
func (x BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey) values() []interface{}          { return x.vs }
func (x BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey) buyOrderBatchSelectorIndexKey() {}

func (this BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey) WithBuyOrderId(buy_order_id uint64) BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey {
	this.vs = []interface{}{buy_order_id}
	return this
}

func (this BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey) WithBuyOrderIdBatchId(buy_order_id uint64, batch_id uint64) BuyOrderBatchSelectorBuyOrderIdBatchIdIndexKey {
	this.vs = []interface{}{buy_order_id, batch_id}
	return this
}

type BuyOrderBatchSelectorBatchIdIndexKey struct {
	vs []interface{}
}

func (x BuyOrderBatchSelectorBatchIdIndexKey) id() uint32                     { return 1 }
func (x BuyOrderBatchSelectorBatchIdIndexKey) values() []interface{}          { return x.vs }
func (x BuyOrderBatchSelectorBatchIdIndexKey) buyOrderBatchSelectorIndexKey() {}

func (this BuyOrderBatchSelectorBatchIdIndexKey) WithBatchId(batch_id uint64) BuyOrderBatchSelectorBatchIdIndexKey {
	this.vs = []interface{}{batch_id}
	return this
}

type buyOrderBatchSelectorTable struct {
	table ormtable.Table
}

func (this buyOrderBatchSelectorTable) Insert(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error {
	return this.table.Insert(ctx, buyOrderBatchSelector)
}

func (this buyOrderBatchSelectorTable) Update(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error {
	return this.table.Update(ctx, buyOrderBatchSelector)
}

func (this buyOrderBatchSelectorTable) Save(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error {
	return this.table.Save(ctx, buyOrderBatchSelector)
}

func (this buyOrderBatchSelectorTable) Delete(ctx context.Context, buyOrderBatchSelector *BuyOrderBatchSelector) error {
	return this.table.Delete(ctx, buyOrderBatchSelector)
}

func (this buyOrderBatchSelectorTable) Has(ctx context.Context, buy_order_id uint64, batch_id uint64) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, buy_order_id, batch_id)
}

func (this buyOrderBatchSelectorTable) Get(ctx context.Context, buy_order_id uint64, batch_id uint64) (*BuyOrderBatchSelector, error) {
	var buyOrderBatchSelector BuyOrderBatchSelector
	found, err := this.table.PrimaryKey().Get(ctx, &buyOrderBatchSelector, buy_order_id, batch_id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &buyOrderBatchSelector, nil
}

func (this buyOrderBatchSelectorTable) List(ctx context.Context, prefixKey BuyOrderBatchSelectorIndexKey, opts ...ormlist.Option) (BuyOrderBatchSelectorIterator, error) {
	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
	return BuyOrderBatchSelectorIterator{it}, err
}

func (this buyOrderBatchSelectorTable) ListRange(ctx context.Context, from, to BuyOrderBatchSelectorIndexKey, opts ...ormlist.Option) (BuyOrderBatchSelectorIterator, error) {
	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
	return BuyOrderBatchSelectorIterator{it}, err
}

func (this buyOrderBatchSelectorTable) DeleteBy(ctx context.Context, prefixKey BuyOrderBatchSelectorIndexKey) error {
	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
}

func (this buyOrderBatchSelectorTable) DeleteRange(ctx context.Context, from, to BuyOrderBatchSelectorIndexKey) error {
	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
}

func (this buyOrderBatchSelectorTable) doNotImplement() {}

var _ BuyOrderBatchSelectorTable = buyOrderBatchSelectorTable{}

func NewBuyOrderBatchSelectorTable(db ormtable.Schema) (BuyOrderBatchSelectorTable, error) {
	table := db.GetTable(&BuyOrderBatchSelector{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&BuyOrderBatchSelector{}).ProtoReflect().Descriptor().FullName()))
	}
	return buyOrderBatchSelectorTable{table}, nil
}

type MemoryStore interface {
	BuyOrderSellOrderMatchTable() BuyOrderSellOrderMatchTable
	BuyOrderClassSelectorTable() BuyOrderClassSelectorTable
	BuyOrderProjectSelectorTable() BuyOrderProjectSelectorTable
	BuyOrderBatchSelectorTable() BuyOrderBatchSelectorTable

	doNotImplement()
}

type memoryStore struct {
	buyOrderSellOrderMatch  BuyOrderSellOrderMatchTable
	buyOrderClassSelector   BuyOrderClassSelectorTable
	buyOrderProjectSelector BuyOrderProjectSelectorTable
	buyOrderBatchSelector   BuyOrderBatchSelectorTable
}

func (x memoryStore) BuyOrderSellOrderMatchTable() BuyOrderSellOrderMatchTable {
	return x.buyOrderSellOrderMatch
}

func (x memoryStore) BuyOrderClassSelectorTable() BuyOrderClassSelectorTable {
	return x.buyOrderClassSelector
}

func (x memoryStore) BuyOrderProjectSelectorTable() BuyOrderProjectSelectorTable {
	return x.buyOrderProjectSelector
}

func (x memoryStore) BuyOrderBatchSelectorTable() BuyOrderBatchSelectorTable {
	return x.buyOrderBatchSelector
}

func (memoryStore) doNotImplement() {}

var _ MemoryStore = memoryStore{}

func NewMemoryStore(db ormtable.Schema) (MemoryStore, error) {
	buyOrderSellOrderMatchTable, err := NewBuyOrderSellOrderMatchTable(db)
	if err != nil {
		return nil, err
	}

	buyOrderClassSelectorTable, err := NewBuyOrderClassSelectorTable(db)
	if err != nil {
		return nil, err
	}

	buyOrderProjectSelectorTable, err := NewBuyOrderProjectSelectorTable(db)
	if err != nil {
		return nil, err
	}

	buyOrderBatchSelectorTable, err := NewBuyOrderBatchSelectorTable(db)
	if err != nil {
		return nil, err
	}

	return memoryStore{
		buyOrderSellOrderMatchTable,
		buyOrderClassSelectorTable,
		buyOrderProjectSelectorTable,
		buyOrderBatchSelectorTable,
	}, nil
}