websocket

type BufferPoolKey struct{}

type CheckOriginKey struct{}

type Connection interface {
	// Emitter implements EmitMessage & Emit
	Emitter
	// Err is not nil if the upgrader failed to upgrade http to websocket connection.
	Err() error

	// ID returns the connection's identifier
	ID() string

	// Server returns the websocket server instance
	// which this connection is listening to.
	//
	// Its connection-relative operations are safe for use.
	Server() *Server

	// Write writes a raw websocket message with a specific type to the client
	// used by ping messages and any CloseMessage types.
	Write(websocketMessageType int, data []byte) error

	// Context returns the (upgraded) context.Context of this connection
	// avoid using it, you normally don't need it,
	// websocket has everything you need to authenticate the user BUT if it's necessary
	// then  you use it to receive user information, for example: from headers
	Context() *gin.Context

	// OnDisconnect registers a callback which is fired when this connection is closed by an error or manual
	OnDisconnect(DisconnectFunc)
	// OnError registers a callback which fires when this connection occurs an error
	OnError(ErrorFunc)
	// OnPing  registers a callback which fires on each ping
	OnPing(PingFunc)
	// OnPong  registers a callback which fires on pong message received
	OnPong(PongFunc)
	// FireOnError can be used to send a custom error message to the connection
	//
	// It does nothing more than firing the OnError listeners. It doesn't send anything to the client.
	FireOnError(err error)
	// To defines on what "room" (see Join) the server should send a message
	// returns an Emmiter(`EmitMessage` & `Emit`) to send messages.
	To(string) Emitter
	// OnMessage registers a callback which fires when native websocket message received
	OnMessage(NativeMessageFunc)
	// On registers a callback to a particular event which is fired when a message to this event is received
	On(string, MessageFunc)
	// Join registers this connection to a room, if it doesn't exist then it creates a new. One room can have one or more connections. One connection can be joined to many rooms. All connections are joined to a room specified by their `ID` automatically.
	Join(string)
	// IsJoined returns true when this connection is joined to the room, otherwise false.
	// It Takes the room name as its input parameter.
	IsJoined(roomName string) bool
	// Leave removes this connection entry from a room
	// Returns true if the connection has actually left from the particular room.
	Leave(string) bool
	// OnLeave registers a callback which fires when this connection left from any joined room.
	// This callback is called automatically on Disconnected client, because websocket server automatically
	// deletes the disconnected connection from any joined rooms.
	//
	// Note: the callback(s) called right before the server deletes the connection from the room
	// so the connection theoretical can still send messages to its room right before it is being disconnected.
	OnLeave(roomLeaveCb LeaveRoomFunc)
	// Wait starts the pinger and the messages reader,
	// it's named as "Wait" because it should be called LAST,
	// after the "On" events IF server's `Upgrade` is used,
	// otherise you don't have to call it because the `Handler()` does it automatically.
	Wait()
	// Disconnect disconnects the client, close the underline websocket conn and removes it from the conn list
	// returns the error, if any, from the underline connection
	Disconnect() error
	// SetValue sets a key-value pair on the connection's mem store.
	SetValue(key string, value interface{})
	// GetValue gets a value by its key from the connection's mem store.
	GetValue(key string) interface{}
	// GetValueArrString gets a value as []string by its key from the connection's mem store.
	GetValueArrString(key string) []string
	// GetValueString gets a value as string by its key from the connection's mem store.
	GetValueString(key string) string
	// GetValueInt gets a value as integer by its key from the connection's mem store.
	GetValueInt(key string) int
}

type ConnectionFunc func(Connection)

type ConnectionValues []connectionValue

type DisconnectFunc func()

type Emitter interface {
	// EmitMessage sends a native websocket message
	EmitMessage([]byte) error
	// Emit sends a message on a particular event
	Emit(string, interface{}) error
}

type ErrorFunc (func(error))

type ErrorKey struct{}

type LeaveRoomFunc func(roomName string)

type MessageFunc interface{}

type NativeMessageFunc func([]byte)

type Option func(*Options)

type Options struct {
	HandshakeTimeout time.Duration

	ReadBufferSize, WriteBufferSize int

	WriteBufferPool websocket.BufferPool

	Subprotocols []string

	Error func(w http.ResponseWriter, r *http.Request, status int, reason error)

	CheckOrigin func(r *http.Request) bool

	EnableCompression bool
}

type PingFunc func()

type PongFunc func()

type Server struct {
	ClientSource []byte
	// contains filtered or unexported fields
}

type UnderlineConnection interface {
	// SetWriteDeadline 设置底层连接写入超时时限, 如果写入超时.  websocket 连接状态变为已损坏,
	// 之后所有的写入操作都会返回错误, t 如果为零值则写入不会超时
	SetWriteDeadline(t time.Time) error
	// SetReadDeadline 设置底层连接读取超时时限, 如果读取超时, websocket 连接状态变为已损坏,
	// 之后所有的读取都会返回错误, t 为零值表明写入不会超时
	SetReadDeadline(t time.Time) error
	// SetReadLimit 设置连接从对等方读取数据的最大大小, 如果超出该值, 则连接将向对等方发送关闭帧并返回 ErrReadLimit 错误
	SetReadLimit(limit int64)
	// SetPongHandler 设置从对等方接收到的 pong 消息的处理函数. h 的 appData 参数是 PONG 框架应用程序数据.
	// 默认的 pong 处理函数什么都不做.
	SetPongHandler(h func(appData string) error)
	// SetPingHandler 设置从对等方接收到的 ping 消息的处理程序。 h 的 appData 参数是 PING 帧应用程序数据。
	// 默认的 ping 处理程序向对等方发送一个 pong。
	SetPingHandler(h func(appData string) error)
	// WriteControl 在给定的期限内写入一条控制消息。允许的消息类型是 CloseMessage、PingMessage 和 PongMessage。
	WriteControl(messageType int, data []byte, deadline time.Time) error
	// WriteMessage 是一个辅助方法，用于使用 NextWriter 获取写入器，写入消息并关闭写入器。
	WriteMessage(messageType int, data []byte) error
	// ReadMessage 是一种帮助方法，用于使用 NextReader 获取阅读器并从该阅读器读取到缓冲区。
	ReadMessage() (messageType int, p []byte, err error)
	// NextWriter 为下一条要发送的消息返回一个 writer。 writer 的 Close 方法将完整的消息刷新到网络。
	// 一个连接上最多可以有一个打开的写入器。如果应用程序尚未关闭前一个写入器，NextWriter 将关闭它。
	NextWriter(messageType int) (io.WriteCloser, error)
	// Close 关闭底层网络连接而不发送或等待关闭帧。
	Close() error
}

type Websocket struct {
	websocket.Upgrader
	// contains filtered or unexported fields
}