bstream

type BasicBlockRef struct {
	// contains filtered or unexported fields
}

type BlockDecoder interface {
	Decode(blk *pbbstream.Block) (any, error)
}

type BlockDecoderFunc func(blk *pbbstream.Block) (any, error)

type BlockIDGate struct {
	MaxHoldOff int
	// contains filtered or unexported fields
}

type BlockIndexProvider interface {
	BlocksInRange(baseBlockNum, bundleSize uint64) (out []uint64, err error)
}

type BlockIndexProviderGetter interface {
	GetIndexProvider() BlockIndexProvider
}

type BlockNumGate struct {
	MaxHoldOff int
	// contains filtered or unexported fields
}

type BlockNumberGator struct {
	// contains filtered or unexported fields
}

type BlockRef interface {
	ID() string
	Num() uint64
	String() string
}

type BlockRefGetter func(context.Context) (BlockRef, error)

type BlockTimestampGate struct {
	MaxHoldOff int
	// contains filtered or unexported fields
}

type BlockWithObj struct {
	Block *pbbstream.Block
	Obj   any
}

type Buffer struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Cursor struct {
	Step  StepType
	Block BlockRef
	LIB   BlockRef // last block sent as irreversible if it exists, else known forkdb LIB

	// HeadBlock will be the same as Block when you receive a 'new' Step, except during a reorg.
	// During a reorg, (steps in ['new','redo','undo']) the HeadBlock will always point to the block that causes the reorg.
	// When the LIB is advancing (ex: DPOSLibNum changes, etc.), step='irreversible' and the HeadBlock will be the block
	// that causes previous blocks to become irreversible.
	// When emitting a partialblock (with StepPartial) the behavior of HeadBlock changes: it now points to the parent block of the partial block.
	HeadBlock BlockRef
}

type Cursorable interface {
	Cursor() *Cursor
}

type DBinBlockReader struct {
	Header *dbin.Header
	// contains filtered or unexported fields
}

type DBinBlockWriter struct {
	// contains filtered or unexported fields
}

type EternalSource struct {
	*shutter.Shutter
	// contains filtered or unexported fields
}

type EternalSourceOption = func(s *EternalSource)

type EternalSourceStartBackAtBlock func() (BlockRef, error)

type FileSource struct {
	*shutter.Shutter
	// contains filtered or unexported fields
}

type FileSourceFactory struct {
	// contains filtered or unexported fields
}

type FileSourceOption = func(s *FileSource)

type ForkableObject interface {
	Cursorable
	Stepable
	ObjectWrapper
}

type ForkableSourceFactory interface {
	SourceFromBlockNum(uint64, Handler) Source // irreversible
	SourceFromCursor(*Cursor, Handler) Source
	SourceThroughCursor(uint64, *Cursor, Handler) Source
}

type ForkedBlockKnower interface {
	HasForkedBlock(ctx context.Context, idSuffix string, blockNum uint64) (bool, error)
}

type Gate interface {
	SetLogger(logger *zap.Logger)
}

type GateOption func(g Gate)

type GateType int

type Gator interface {
	Pass(block *pbbstream.Block) bool
}

type Handler interface {
	ProcessBlock(blk *pbbstream.Block, obj any) error
}

type HandlerFunc func(blk *pbbstream.Block, obj any) error

type JoiningSource struct {
	*shutter.Shutter
	// contains filtered or unexported fields
}

type JoiningSourceOption func(s *JoiningSource)

type LiveBlockKnower interface {
	LowestBlockNum() uint64
	HeadNum() uint64
	GetBlockByHash(id string) *pbbstream.Block
}

type Liveable interface {
	IsLiveBlock() bool // Returns true if the object was sent by a live stream, without any buffer
	SetLiveBlock(bool) // Used to set the live status of the object, let's say you hit a full buffer and want to switch it to false
}

type LowSourceLimitGetter interface {
	LowestBlockNum() uint64
}

type MinimalBlockNumFilter struct {
	// contains filtered or unexported fields
}

type MockSource struct {
	*shutter.Shutter
	// contains filtered or unexported fields
}

type MultiplexedSource struct {
	*shutter.Shutter
	// contains filtered or unexported fields
}

type MultiplexedSourceOption = func(s *MultiplexedSource)

type ObjectWrapper interface {
	WrappedObject() any
}

type OneBlockDownloaderFunc = func(ctx context.Context, oneBlockFile *OneBlockFile) (data []byte, err error)

type OneBlockFile struct {
	sync.Mutex
	CanonicalName string
	Filenames     map[string]bool
	ID            string
	Num           uint64
	LibNum        uint64
	PreviousID    string
	MemoizeData   []byte
	Deleted       bool
}

type OneBlocksSourceOption func(*oneBlocksSource)

type ParsableTestBlock struct {
	ID        string `json:"id,omitempty"`
	ParentID  string `json:"prev,omitempty"`
	ParentNum uint64 `json:"prevnum,omitempty"`
	Number    uint64 `json:"num,omitempty"`
	LIBNum    uint64 `json:"libnum,omitempty"`
	Timestamp string `json:"time,omitempty"`
	Kind      int32  `json:"kind,omitempty"`
	Version   int32  `json:"version,omitempty"`
}

type ParseRangeOption interface {
	// contains filtered or unexported methods
}

type PreprocessFunc func(blk *pbbstream.Block) (any, error)

type PreprocessedBlock struct {
	Block *pbbstream.Block
	Obj   interface{}
}

type Preprocessor struct {
	// contains filtered or unexported fields
}

type Pretty interface {
	Pretty() string
}

type Range struct {
	// contains filtered or unexported fields
}

type RangeOptions func(p *Range) *Range

type RealtimeGate struct {
	// contains filtered or unexported fields
}

type RealtimeTripper struct {
	// contains filtered or unexported fields
}

type RecentBlockGetter struct {
	// contains filtered or unexported fields
}

type Shutterer interface {
	Shutdown(error)
	Terminating() <-chan struct{}
	IsTerminating() bool
	Terminated() <-chan struct{}
	IsTerminated() bool
	OnTerminating(f func(error))
	OnTerminated(f func(error))
	Err() error
}

type Source interface {
	Shutterer
	Run()
}

type SourceFactory func(h Handler) Source

type SourceFromNumFactory func(startBlockNum uint64, h Handler) Source

type SourceFromNumFactoryWithSkipFunc func(startBlockNum uint64, h Handler, skipFunc func(idSuffix string) bool) Source

type SourceFromRefFactory func(startBlockRef BlockRef, h Handler) Source

type StepType int

type Stepable interface {
	Step() StepType
	FinalBlockHeight() uint64
	ReorgJunctionBlock() BlockRef
}

type TailLock struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type TailLockOption = func(s *TailLock)

type Target string

type TestBlockIndexProvider struct {
	Blocks           []uint64
	LastIndexedBlock uint64
	ThrowError       error
}

type TestBlockReader struct {
	// contains filtered or unexported fields
}

type TestBlockReaderBin struct {
	DBinReader *dbin.Reader
}

type TestBlockWriterBin struct {
	DBinWriter *dbin.Writer
}

type TestSource struct {
	*shutter.Shutter

	StartBlockID      string
	StartBlockNum     uint64
	Cursor            *Cursor
	PassThroughCursor bool
	// contains filtered or unexported fields
}

type TestSourceFactory struct {
	Created           chan *TestSource
	FromBlockNumFunc  func(uint64, Handler) Source
	FromCursorFunc    func(*Cursor, Handler) Source
	ThroughCursorFunc func(uint64, *Cursor, Handler) Source
	LowestBlkNum      uint64
}

type TimeThresholdGator struct {
	// contains filtered or unexported fields
}

type Tracker struct {
	// contains filtered or unexported fields
}