sink

type SinkClientMethods interface {
	// Sync always returns nil.
	Sink(_ *context.T, Payload []byte, _ ...rpc.CallOpt) error
	// SyncStream always returns nil.
	SinkStream(*context.T, ...rpc.CallOpt) (SinkSinkStreamClientCall, error)
}

type SinkClientStub interface {
	SinkClientMethods
	rpc.UniversalServiceMethods
}

type SinkServerMethods interface {
	// Sync always returns nil.
	Sink(_ *context.T, _ rpc.ServerCall, Payload []byte) error
	// SyncStream always returns nil.
	SinkStream(*context.T, SinkSinkStreamServerCall) error
}

type SinkServerStub interface {
	SinkServerStubMethods
	// Describe the Sink interfaces.
	Describe__() []rpc.InterfaceDesc
}

type SinkServerStubMethods interface {
	// Sync always returns nil.
	Sink(_ *context.T, _ rpc.ServerCall, Payload []byte) error
	// SyncStream always returns nil.
	SinkStream(*context.T, *SinkSinkStreamServerCallStub) error
}

type SinkSinkStreamClientCall interface {
	SinkSinkStreamClientStream
	// Finish performs the equivalent of SendStream().Close, then blocks until
	// the server is done, and returns the positional return values for the call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error.  Finish should
	// be called at most once.
	Finish() error
}

type SinkSinkStreamClientStream interface {
	// SendStream returns the send side of the Sink.SinkStream client stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors
		// encountered while sending, or if Send is called after Close or
		// the stream has been canceled.  Blocks if there is no buffer
		// space; will unblock when buffer space is available or after
		// the stream has been canceled.
		Send(item []byte) error
		// Close indicates to the server that no more items will be sent;
		// server Recv calls will receive io.EOF after all sent items.
		// This is an optional call - e.g. a client might call Close if it
		// needs to continue receiving items from the server after it's
		// done sending.  Returns errors encountered while closing, or if
		// Close is called after the stream has been canceled.  Like Send,
		// blocks if there is no buffer space available.
		Close() error
	}
}

type SinkSinkStreamServerCall interface {
	rpc.ServerCall
	SinkSinkStreamServerStream
}

type SinkSinkStreamServerCallStub struct {
	rpc.StreamServerCall
	// contains filtered or unexported fields
}

type SinkSinkStreamServerStream interface {
	// RecvStream returns the receiver side of the Sink.SinkStream server stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() []byte
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
}