sonr/api/svc/v1/state.cosmos_orm.go

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

package svcv1

import (
	context "context"
	ormlist "cosmossdk.io/orm/model/ormlist"
	ormtable "cosmossdk.io/orm/model/ormtable"
	ormerrors "cosmossdk.io/orm/types/ormerrors"
)

type DomainTable interface {
	Insert(ctx context.Context, domain *Domain) error
	InsertReturningId(ctx context.Context, domain *Domain) (uint64, error)
	LastInsertedSequence(ctx context.Context) (uint64, error)
	Update(ctx context.Context, domain *Domain) error
	Save(ctx context.Context, domain *Domain) error
	Delete(ctx context.Context, domain *Domain) error
	Has(ctx context.Context, 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, id uint64) (*Domain, error)
	HasByOrigin(ctx context.Context, origin string) (found bool, err error)
	// GetByOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetByOrigin(ctx context.Context, origin string) (*Domain, error)
	List(ctx context.Context, prefixKey DomainIndexKey, opts ...ormlist.Option) (DomainIterator, error)
	ListRange(ctx context.Context, from, to DomainIndexKey, opts ...ormlist.Option) (DomainIterator, error)
	DeleteBy(ctx context.Context, prefixKey DomainIndexKey) error
	DeleteRange(ctx context.Context, from, to DomainIndexKey) error

	doNotImplement()
}

type DomainIterator struct {
	ormtable.Iterator
}

func (i DomainIterator) Value() (*Domain, error) {
	var domain Domain
	err := i.UnmarshalMessage(&domain)
	return &domain, err
}

type DomainIndexKey interface {
	id() uint32
	values() []interface{}
	domainIndexKey()
}

// primary key starting index..
type DomainPrimaryKey = DomainIdIndexKey

type DomainIdIndexKey struct {
	vs []interface{}
}

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

func (this DomainIdIndexKey) WithId(id uint64) DomainIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type DomainOriginIndexKey struct {
	vs []interface{}
}

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

func (this DomainOriginIndexKey) WithOrigin(origin string) DomainOriginIndexKey {
	this.vs = []interface{}{origin}
	return this
}

type domainTable struct {
	table ormtable.AutoIncrementTable
}

func (this domainTable) Insert(ctx context.Context, domain *Domain) error {
	return this.table.Insert(ctx, domain)
}

func (this domainTable) Update(ctx context.Context, domain *Domain) error {
	return this.table.Update(ctx, domain)
}

func (this domainTable) Save(ctx context.Context, domain *Domain) error {
	return this.table.Save(ctx, domain)
}

func (this domainTable) Delete(ctx context.Context, domain *Domain) error {
	return this.table.Delete(ctx, domain)
}

func (this domainTable) InsertReturningId(ctx context.Context, domain *Domain) (uint64, error) {
	return this.table.InsertReturningPKey(ctx, domain)
}

func (this domainTable) LastInsertedSequence(ctx context.Context) (uint64, error) {
	return this.table.LastInsertedSequence(ctx)
}

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

func (this domainTable) Get(ctx context.Context, id uint64) (*Domain, error) {
	var domain Domain
	found, err := this.table.PrimaryKey().Get(ctx, &domain, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &domain, nil
}

func (this domainTable) HasByOrigin(ctx context.Context, origin string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		origin,
	)
}

func (this domainTable) GetByOrigin(ctx context.Context, origin string) (*Domain, error) {
	var domain Domain
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &domain,
		origin,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &domain, nil
}

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

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

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

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

func (this domainTable) doNotImplement() {}

var _ DomainTable = domainTable{}

func NewDomainTable(db ormtable.Schema) (DomainTable, error) {
	table := db.GetTable(&Domain{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&Domain{}).ProtoReflect().Descriptor().FullName()))
	}
	return domainTable{table.(ormtable.AutoIncrementTable)}, nil
}

type MetadataTable interface {
	Insert(ctx context.Context, metadata *Metadata) error
	Update(ctx context.Context, metadata *Metadata) error
	Save(ctx context.Context, metadata *Metadata) error
	Delete(ctx context.Context, metadata *Metadata) error
	Has(ctx context.Context, id string) (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, id string) (*Metadata, error)
	HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error)
	// GetBySubjectOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
	GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Metadata, error)
	List(ctx context.Context, prefixKey MetadataIndexKey, opts ...ormlist.Option) (MetadataIterator, error)
	ListRange(ctx context.Context, from, to MetadataIndexKey, opts ...ormlist.Option) (MetadataIterator, error)
	DeleteBy(ctx context.Context, prefixKey MetadataIndexKey) error
	DeleteRange(ctx context.Context, from, to MetadataIndexKey) error

	doNotImplement()
}

type MetadataIterator struct {
	ormtable.Iterator
}

func (i MetadataIterator) Value() (*Metadata, error) {
	var metadata Metadata
	err := i.UnmarshalMessage(&metadata)
	return &metadata, err
}

type MetadataIndexKey interface {
	id() uint32
	values() []interface{}
	metadataIndexKey()
}

// primary key starting index..
type MetadataPrimaryKey = MetadataIdIndexKey

type MetadataIdIndexKey struct {
	vs []interface{}
}

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

func (this MetadataIdIndexKey) WithId(id string) MetadataIdIndexKey {
	this.vs = []interface{}{id}
	return this
}

type MetadataSubjectOriginIndexKey struct {
	vs []interface{}
}

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

func (this MetadataSubjectOriginIndexKey) WithSubject(subject string) MetadataSubjectOriginIndexKey {
	this.vs = []interface{}{subject}
	return this
}

func (this MetadataSubjectOriginIndexKey) WithSubjectOrigin(subject string, origin string) MetadataSubjectOriginIndexKey {
	this.vs = []interface{}{subject, origin}
	return this
}

type metadataTable struct {
	table ormtable.Table
}

func (this metadataTable) Insert(ctx context.Context, metadata *Metadata) error {
	return this.table.Insert(ctx, metadata)
}

func (this metadataTable) Update(ctx context.Context, metadata *Metadata) error {
	return this.table.Update(ctx, metadata)
}

func (this metadataTable) Save(ctx context.Context, metadata *Metadata) error {
	return this.table.Save(ctx, metadata)
}

func (this metadataTable) Delete(ctx context.Context, metadata *Metadata) error {
	return this.table.Delete(ctx, metadata)
}

func (this metadataTable) Has(ctx context.Context, id string) (found bool, err error) {
	return this.table.PrimaryKey().Has(ctx, id)
}

func (this metadataTable) Get(ctx context.Context, id string) (*Metadata, error) {
	var metadata Metadata
	found, err := this.table.PrimaryKey().Get(ctx, &metadata, id)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &metadata, nil
}

func (this metadataTable) HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error) {
	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
		subject,
		origin,
	)
}

func (this metadataTable) GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Metadata, error) {
	var metadata Metadata
	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &metadata,
		subject,
		origin,
	)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, ormerrors.NotFound
	}
	return &metadata, nil
}

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

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

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

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

func (this metadataTable) doNotImplement() {}

var _ MetadataTable = metadataTable{}

func NewMetadataTable(db ormtable.Schema) (MetadataTable, error) {
	table := db.GetTable(&Metadata{})
	if table == nil {
		return nil, ormerrors.TableNotFound.Wrap(string((&Metadata{}).ProtoReflect().Descriptor().FullName()))
	}
	return metadataTable{table}, nil
}

type StateStore interface {
	DomainTable() DomainTable
	MetadataTable() MetadataTable

	doNotImplement()
}

type stateStore struct {
	domain   DomainTable
	metadata MetadataTable
}

func (x stateStore) DomainTable() DomainTable {
	return x.domain
}

func (x stateStore) MetadataTable() MetadataTable {
	return x.metadata
}

func (stateStore) doNotImplement() {}

var _ StateStore = stateStore{}

func NewStateStore(db ormtable.Schema) (StateStore, error) {
	domainTable, err := NewDomainTable(db)
	if err != nil {
		return nil, err
	}

	metadataTable, err := NewMetadataTable(db)
	if err != nil {
		return nil, err
	}

	return stateStore{
		domainTable,
		metadataTable,
	}, nil
}