netty

type Action = func()

type ActiveContext interface {
	HandlerContext
	HandleActive()
}

type ActiveHandler interface {
	HandleActive(ctx ActiveContext)
}

type ActiveHandlerFunc func(ctx ActiveContext)

type Attachment interface {
}

type Bootstrap interface {
	// Context return context
	Context() context.Context
	// Listen create a listener
	Listen(url string, option ...transport.Option) Listener
	// Connect to remote endpoint
	Connect(url string, option ...transport.Option) (Channel, error)
	// Shutdown boostrap
	Shutdown()
}

type Channel interface {
	// ID channel id
	ID() int64

	// Write a message through the Pipeline
	Write(Message) error

	// Trigger user event
	Trigger(event Event)

	// Close through the Pipeline
	Close(err error)

	// IsActive return true if the Channel is active and so connected
	IsActive() bool

	// Writev to write [][]byte for optimize syscall
	Writev([][]byte) (int64, error)

	// Write1 to write []byte to channel
	Write1(p []byte) (n int, err error)

	// LocalAddr local address
	LocalAddr() string

	// RemoteAddr remote address
	RemoteAddr() string

	// Transport get transport of channel
	Transport() transport.Transport

	// Pipeline get pipeline of channel
	Pipeline() Pipeline

	// Attachment get attachment
	Attachment() Attachment

	// SetAttachment set attachment
	SetAttachment(Attachment)

	// Context channel context
	Context() context.Context
	// contains filtered or unexported methods
}

type ChannelFactory func(id int64, ctx context.Context, pipeline Pipeline, transport transport.Transport, executor Executor) Channel

type ChannelHandler interface {
	ActiveHandler
	InboundHandler
	OutboundHandler
	ExceptionHandler
	InactiveHandler
}

type ChannelHolder interface {
	ActiveHandler
	InactiveHandler
	// CloseAll close the all channels
	CloseAll(err error)
}

type ChannelIDFactory func() int64

type ChannelInboundHandler interface {
	ActiveHandler
	InboundHandler
	InactiveHandler
}

type ChannelInitializer func(Channel)

type ChannelOutboundHandler interface {
	ActiveHandler
	OutboundHandler
	InactiveHandler
}

type CodecHandler interface {
	CodecName() string
	InboundHandler
	OutboundHandler
}

type Event interface {
}

type EventContext interface {
	HandlerContext
	HandleEvent(event Event)
}

type EventHandler interface {
	HandleEvent(ctx EventContext, event Event)
}

type EventHandlerFunc func(ctx EventContext, event Event)

type Exception = error

type ExceptionContext interface {
	HandlerContext
	HandleException(ex Exception)
}

type ExceptionHandler interface {
	HandleException(ctx ExceptionContext, ex Exception)
}

type ExceptionHandlerFunc func(ctx ExceptionContext, ex Exception)

type Executor interface {
	Exec(Action)
}

type Handler interface {
}

type HandlerContext interface {
	Channel() Channel
	Handler() Handler
	Write(message Message)
	Trigger(event Event)
	Close(err error)
	Attachment() Attachment
	SetAttachment(Attachment)
}

type InactiveContext interface {
	HandlerContext
	HandleInactive(ex Exception)
}

type InactiveHandler interface {
	HandleInactive(ctx InactiveContext, ex Exception)
}

type InactiveHandlerFunc func(ctx InactiveContext, ex Exception)

type InboundContext interface {
	HandlerContext
	HandleRead(message Message)
}

type InboundHandler interface {
	HandleRead(ctx InboundContext, message Message)
}

type InboundHandlerFunc func(ctx InboundContext, message Message)

type Listener interface {
	// Close the listener
	Close() error
	// Sync waits for this listener until it is done
	Sync() error
	// Async nonblock waits for this listener
	Async(func(error))
}

type Message interface {
}

type Option func(options *bootstrapOptions)

type OutboundContext interface {
	HandlerContext
	HandleWrite(message Message)
}

type OutboundHandler interface {
	HandleWrite(ctx OutboundContext, message Message)
}

type OutboundHandlerFunc func(ctx OutboundContext, message Message)

type Pipeline interface {

	// AddFirst add a handler to the first.
	AddFirst(handlers ...Handler) Pipeline

	// AddLast add a handler to the last.
	AddLast(handlers ...Handler) Pipeline

	// AddHandler add handlers in position.
	AddHandler(position int, handlers ...Handler) Pipeline

	// IndexOf find fist index of handler.
	IndexOf(func(Handler) bool) int

	// LastIndexOf find last index of handler.
	LastIndexOf(func(Handler) bool) int

	// ContextAt get context by position.
	ContextAt(position int) HandlerContext

	// Size of handler
	Size() int

	// Channel get channel.
	Channel() Channel

	// ServeChannel serve the channel.
	ServeChannel(channel Channel)

	FireChannelActive()
	FireChannelRead(message Message)
	FireChannelWrite(message Message)
	FireChannelException(ex Exception)
	FireChannelInactive(ex Exception)
	FireChannelEvent(event Event)
}

type PipelineFactory func() Pipeline

type ReadIdleEvent struct{}

type SimpleChannelHandler = ChannelInboundHandler

type TransportFactory transport.Factory

type WriteIdleEvent struct{}