remote

type BoundHandler interface{}

type ByteBuffer interface {
	io.ReadWriter

	// Next reads the next n bytes sequentially and returns the original buffer.
	Next(n int) (p []byte, err error)

	// Peek returns the next n bytes without advancing the reader.
	Peek(n int) (buf []byte, err error)

	// Skip is used to skip the next few bytes quickly. It's faster than Next and doesn't cause release.
	Skip(n int) (err error)

	// Release will free the buffer. After release, buffer read by Next/Skip/Peek is invalid.
	// Param e is used when the buffer release depend on error.
	// For example, usually the write buffer will be released inside flush,
	// but if flush error happen, write buffer may need to be released explicitly.
	Release(e error) (err error)

	// ReadableLen returns the total length of readable buffer.
	// Return: -1 means unreadable.
	ReadableLen() (n int)

	// ReadLen returns the size already read.
	ReadLen() (n int)

	// ReadString is a more efficient way to read string than Next.
	ReadString(n int) (s string, err error)

	// ReadBinary like ReadString.
	// Returns a copy of original buffer.
	ReadBinary(n int) (p []byte, err error)

	// Malloc n bytes sequentially in the writer buffer.
	Malloc(n int) (buf []byte, err error)

	// MallocLen returns the total length of the buffer malloced.
	MallocLen() (length int)

	// WriteString is a more efficient way to write string, using the unsafe method to convert the string to []byte.
	WriteString(s string) (n int, err error)

	// WriteBinary writes the []byte directly. Callers must guarantee that the []byte doesn't change.
	WriteBinary(b []byte) (n int, err error)

	// Flush writes any malloc data to the underlying io.Writer.
	// The malloced buffer must be set correctly.
	Flush() (err error)

	// NewBuffer returns a new writable remote.ByteBuffer.
	NewBuffer() ByteBuffer
	// AppendBuffer appends buf to the original buffer.
	AppendBuffer(buf ByteBuffer) (err error)

	// Bytes return the backing bytes slice of this buffer
	Bytes() (buf []byte, err error)
}

type ByteBufferFactory interface {
	NewByteBuffer(conn net.Conn) (ByteBuffer, error)
}

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

type ClientOption struct {
	SvcInfo *serviceinfo.ServiceInfo

	CliHandlerFactory ClientTransHandlerFactory

	Codec Codec

	PayloadCodec PayloadCodec

	ConnPool ConnPool

	Dialer Dialer

	Option

	EnableConnPoolReporter bool
}

type ClientTransHandler interface {
	TransHandler
}

type ClientTransHandlerFactory interface {
	NewTransHandler(opt *ClientOption) (ClientTransHandler, error)
}

type Codec interface {
	Encode(ctx context.Context, msg Message, out ByteBuffer) error
	Decode(ctx context.Context, msg Message, in ByteBuffer) error
	Name() string
}

type CompressType int32

type ConnOption struct {
	Dialer         Dialer
	ConnectTimeout time.Duration
}

type ConnPool interface {
	// Get returns a connection to the given address.
	Get(ctx context.Context, network, address string, opt ConnOption) (net.Conn, error)

	// Put puts the connection back to pool.
	// Note that the Close method of conn may already be invoked.
	Put(conn net.Conn) error

	// Discard discards the connection rather than putting it to the pool.
	Discard(conn net.Conn) error

	// Close is to release resource of ConnPool, it is executed when client is closed.
	Close() error
}

type ConnPoolReporter interface {
	EnableReporter()
}

type Dialer interface {
	DialTimeout(network, address string, timeout time.Duration) (net.Conn, error)
}

type DuplexBoundHandler interface {
	OutboundHandler
	InboundHandler
}

type InboundHandler interface {
	BoundHandler
	OnActive(ctx context.Context, conn net.Conn) (context.Context, error)
	OnInactive(ctx context.Context, conn net.Conn) context.Context
	OnRead(ctx context.Context, conn net.Conn) (context.Context, error)
	OnMessage(ctx context.Context, args, result Message) (context.Context, error)
}

type InvokeHandleFuncSetter interface {
	SetInvokeHandleFunc(inkHdlFunc endpoint.Endpoint)
}

type IsActive interface {
	IsActive() bool
}

type LongConnPool interface {
	ConnPool

	// Clean the state maintained in the poor for this address
	Clean(network, address string)
}

type Message interface {
	RPCInfo() rpcinfo.RPCInfo
	ServiceInfo() *serviceinfo.ServiceInfo
	Data() interface{}
	NewData(method string) (ok bool)
	MessageType() MessageType
	SetMessageType(MessageType)
	RPCRole() RPCRole
	PayloadLen() int
	SetPayloadLen(size int)
	TransInfo() TransInfo
	Tags() map[string]interface{}
	ProtocolInfo() ProtocolInfo
	SetProtocolInfo(ProtocolInfo)
	PayloadCodec() PayloadCodec
	SetPayloadCodec(pc PayloadCodec)
	Recycle()
}

type MessageType int32

type MetaHandler interface {
	WriteMeta(ctx context.Context, msg Message) (context.Context, error)
	ReadMeta(ctx context.Context, msg Message) (context.Context, error)
}

type NocopyWrite interface {
	// the buf will be wrapped as a new data node no copy, then insert into the linked buffer.
	// remainCap is the remain capacity of origin buff.
	WriteDirect(buf []byte, remainCap int) error
}

type Option struct {
	Outbounds []OutboundHandler

	Inbounds []InboundHandler

	StreamingMetaHandlers []StreamingMetaHandler
}

type OutboundHandler interface {
	BoundHandler
	Write(ctx context.Context, conn net.Conn, send Message) (context.Context, error)
}

type PayloadCodec interface {
	Marshal(ctx context.Context, message Message, out ByteBuffer) error
	Unmarshal(ctx context.Context, message Message, in ByteBuffer) error
	Name() string
}

type ProtocolInfo struct {
	TransProto transport.Protocol
	CodecType  serviceinfo.PayloadCodec
}

type RPCRole int

type RawConn interface {
	RawConn() net.Conn
}

type ServerOption struct {
	SvcInfo *serviceinfo.ServiceInfo

	TransServerFactory TransServerFactory

	SvrHandlerFactory ServerTransHandlerFactory

	Codec Codec

	PayloadCodec PayloadCodec

	Address net.Addr

	ReusePort bool

	// Duration that server waits for to allow any existing connection to be closed gracefully.
	ExitWaitTime time.Duration

	// Duration that server waits for after error occurs during connection accepting.
	AcceptFailedDelayTime time.Duration

	// Duration that the accepted connection waits for to read or write data.
	MaxConnectionIdleTime time.Duration

	ReadWriteTimeout time.Duration

	InitRPCInfoFunc func(context.Context, net.Addr) (rpcinfo.RPCInfo, context.Context)

	TracerCtl *internal_stats.Controller

	GRPCCfg *grpc.ServerConfig

	Option
}

type ServerTransHandler interface {
	TransHandler
	OnActive(ctx context.Context, conn net.Conn) (context.Context, error)
	OnRead(ctx context.Context, conn net.Conn) error
}

type ServerTransHandlerFactory interface {
	NewTransHandler(opt *ServerOption) (ServerTransHandler, error)
}

type StreamingMetaHandler interface {
	// writes metadata before create a stream
	OnConnectStream(ctx context.Context) (context.Context, error)
	// reads metadata before read first message from stream
	OnReadStream(ctx context.Context) (context.Context, error)
}

type SynthesizedDialer struct {
	DialFunc func(network, address string, timeout time.Duration) (net.Conn, error)
}

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

type TransHandler interface {
	TransReadWriter
	OnInactive(ctx context.Context, conn net.Conn)
	OnError(ctx context.Context, err error, conn net.Conn)
	OnMessage(ctx context.Context, args, result Message) (context.Context, error)
	SetPipeline(pipeline *TransPipeline)
}

type TransInfo interface {
	TransStrInfo() map[string]string
	TransIntInfo() map[uint16]string
	PutTransIntInfo(map[uint16]string)
	PutTransStrInfo(kvInfo map[string]string)
	Recycle()
}

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

type TransReadWriter interface {
	Write(ctx context.Context, conn net.Conn, send Message) error
	Read(ctx context.Context, conn net.Conn, msg Message) error
}

type TransServer interface {
	CreateListener(net.Addr) (net.Listener, error)
	BootstrapServer() (err error)
	Shutdown() error
	ConnCount() utils.AtomicInt
}

type TransServerFactory interface {
	NewTransServer(opt *ServerOption, transHdlr ServerTransHandler) TransServer
}

type TypeID interface {
	TypeID() int32
}

type TypeId interface {
	TypeId() int32
}