stream

type ChunkDelivery struct {
	Ruid   uint
	Chunks []DeliveredChunk
}

type DeliveredChunk struct {
	Addr storage.Address //chunk address
	Data []byte          //chunk data
}

type GetRange struct {
	Ruid      uint
	Stream    ID
	From      uint64
	To        *uint64 `rlp:"nil"`
	BatchSize uint
}

type ID struct {
	// Name is used for the Stream provider identification
	Name string
	// Key is the name of specific data stream within the stream provider. The semantics of this value
	// is at the discretion of the stream provider implementation
	Key string
}

type OfferedHashes struct {
	Ruid      uint
	LastIndex uint64
	Hashes    []byte
}

type Peer struct {
	*network.BzzPeer
	// contains filtered or unexported fields
}

type PeerInfo struct {
	Base      string                       `json:"base"` // our node's base address
	Kademlia  string                       `json:"kademlia"`
	Peers     []PeerState                  `json:"peers"`
	Cursors   map[string]map[string]uint64 `json:"cursors"`
	Intervals map[string]string            `json:"intervals"`
}

type PeerState struct {
	Peer    string            `json:"peer"` // the peer address
	Cursors map[string]uint64 `json:"cursors"`
}

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

type StreamDescriptor struct {
	Stream  ID
	Cursor  uint64
	Bounded bool
}

type StreamInfoReq struct {
	Streams []ID
}

type StreamInfoRes struct {
	Streams []StreamDescriptor
}

type StreamProvider interface {

	// NeedData informs the caller whether a certain chunk needs to be fetched from another peer or not
	NeedData(ctx context.Context, addr ...chunk.Address) ([]bool, error)

	// Get a set of chunks identified by addr from the local storage
	Get(ctx context.Context, addr ...chunk.Address) ([]chunk.Chunk, error)

	// Put a set of chunks into the local storage
	Put(ctx context.Context, ch ...chunk.Chunk) (exists []bool, err error)

	// Set a set of chunks as synced in the localstore
	Set(ctx context.Context, addrs ...chunk.Address) error

	// Subscribe to a data stream from an arbitrary data source
	Subscribe(ctx context.Context, key interface{}, from, to uint64) (<-chan chunk.Descriptor, func())

	// Cursor returns the last known Cursor for a given Stream Key string
	Cursor(string) (uint64, error)

	// InitPeer is a provider specific implementation on how to maintain running streams with
	// an arbitrary Peer. This method should always be run in a separate goroutine
	InitPeer(p *Peer)

	// WantStream indicates if we are interested in a stream
	WantStream(*Peer, ID) bool

	// StreamName returns the Name of the Stream (see ID)
	StreamName() string

	// ParseStream from a standard pipe-separated string and return the Stream Key
	ParseKey(string) (interface{}, error)

	// EncodeStream from a Stream Key to a Stream pipe-separated string representation
	EncodeKey(interface{}) (string, error)

	// Autostart indicates if the stream should autostart
	Autostart() bool

	// Boundedness indicates if the stream is bounded or not
	Boundedness() bool

	// Close the provider
	Close()
}

type StreamState struct {
	Stream  ID
	Code    uint16
	Message string
}

type WantedHashes struct {
	Ruid      uint
	BitVector []byte
}