handler

Documentation

Index

• func RegisterEvent[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventForce[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventForceBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventForceSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventForceSingleBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterEventSingleBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, ...)
• func RegisterRPC[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), ...)
• func RegisterRPCForce[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), ...)
• func RegisterRPCForceSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), ...)
• func RegisterRPCResp[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, ...)
• func RegisterRPCRespForce[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, ...)
• func RegisterRPCRespForceSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, ...)
• func RegisterRPCRespSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, ...)
• func RegisterRPCSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], ...](h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), ...)
• type Elem
  • func (this_ *Elem[CTX, T]) Call(c CTX) *berror.ErrMsg
  • func (this_ *Elem[CTX, T]) IsForce() bool
  • func (this_ *Elem[CTX, T]) IsRPC() bool
  • func (this_ *Elem[CTX, T]) IsRPCResp() bool
  • func (this_ *Elem[CTX, T]) IsSingle() bool
  • func (this_ *Elem[CTX, T]) MsgName() string
  • func (this_ *Elem[CTX, T]) ReqPool() *sync.Pool
  • func (this_ *Elem[CTX, T]) RespPool() *sync.Pool
  • func (this_ *Elem[CTX, T]) String() string
• type HandleFunc
• type Handler
  • func NewHandler[CTX ctx.IContextPtr[T], T any](middlewares ...MiddleWare[CTX, T]) *Handler[CTX, T]
  • func (h *Handler[CTX, T]) GetBroadcastSubjInfo() map[string]struct{}
  • func (h *Handler[CTX, T]) GetHandler(msgName string) (*Elem[CTX, T], bool)
  • func (h *Handler[CTX, T]) GetQueueSubjInfo() map[string]struct{}
  • func (h *Handler[CTX, T]) Group(middlewares ...MiddleWare[CTX, T]) *Handler[CTX, T]
  • func (h *Handler[CTX, T]) Logger()
• type MiddleWare

Functions

func RegisterEvent

func RegisterEvent[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEvent Call in many goroutines, just one sub will receive the event

func RegisterEventBroadcast

func RegisterEventBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventBroadcast Call in many goroutines,and all subscribers will receive

func RegisterEventForce

func RegisterEventForce[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventForce f is force handle when Server is busy many goroutines it is only used for very important businesses, such as recharge-related interfaces, adding gold coins to players, etc. just one sub will receive the event

func RegisterEventForceBroadcast

func RegisterEventForceBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventForceBroadcast f is force handle when Server is busy many goroutines it is only used for very important businesses, such as recharge-related interfaces, adding gold coins to players, etc. all subscribers will receive

func RegisterEventForceSingle

func RegisterEventForceSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventForceSingle f is force handle when Server is busy on eventloop just one sub will receive the event

func RegisterEventForceSingleBroadcast

func RegisterEventForceSingleBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventForceSingleBroadcast f is force handle when Server is busy on eventloop all subscribers will receive

func RegisterEventSingle

func RegisterEventSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventSingle Call in eventloop, just one sub will receive the event

func RegisterEventSingleBroadcast

func RegisterEventSingleBroadcast[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], T any, T1 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterEventSingleBroadcast Call in eventloop ,and all subscribers will receive

func RegisterRPC

func RegisterRPC[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), middlewares ...MiddleWare[CTX, T],
)

RegisterRPC RESP is out parameter and Call in many goroutines,just one sub will receive the event

func RegisterRPCForce

func RegisterRPCForce[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), middlewares ...MiddleWare[CTX, T],
)

RegisterRPCForce f is force handle when Server is busy many goroutines it is only used for very important businesses, such as recharge-related interfaces, adding gold coins to players, etc. just one sub will receive the event

func RegisterRPCForceSingle

func RegisterRPCForceSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), middlewares ...MiddleWare[CTX, T],
)

RegisterRPCForceSingle f is force handle when Server is busy on eventloop，just one sub will receive the event

func RegisterRPCResp

func RegisterRPCResp[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterRPCResp RESP is in parameter and Call in many goroutines，just one sub will receive the event

func RegisterRPCRespForce

func RegisterRPCRespForce[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterRPCRespForce f is force handle when Server is busy many goroutines It is only used for very important businesses, such as recharge-related interfaces, adding gold coins to players, etc. just one sub will receive the event

func RegisterRPCRespForceSingle

func RegisterRPCRespForceSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterRPCRespForceSingle f is force handle when Server is busy on eventloop，just one sub will receive the event

func RegisterRPCRespSingle

func RegisterRPCRespSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ, RESP) *berror.ErrMsg, middlewares ...MiddleWare[CTX, T],
)

RegisterRPCRespSingle RESP is in parameter and Call in eventloop，just one sub will receive the event

func RegisterRPCSingle

func RegisterRPCSingle[CTX ctx.IContextPtr[T], REQ define.ProtoMessagePtr[T1], RESP define.ProtoMessagePtr[T2], T any, T1 any, T2 any](
	h *Handler[CTX, T], desc string, f func(CTX, REQ) (RESP, *berror.ErrMsg), middlewares ...MiddleWare[CTX, T],
)

RegisterRPCSingle RESP is out parameter and Call on eventloop,just one sub will receive the event

Types

type Elem

type Elem[CTX ctx.IContextPtr[T], T any] struct {
	// contains filtered or unexported fields
}

func (*Elem[CTX, T]) Call

func (this_ *Elem[CTX, T]) Call(c CTX) *berror.ErrMsg

func (*Elem[CTX, T]) IsForce

func (this_ *Elem[CTX, T]) IsForce() bool

func (*Elem[CTX, T]) IsRPC

func (this_ *Elem[CTX, T]) IsRPC() bool

func (*Elem[CTX, T]) IsRPCResp

func (this_ *Elem[CTX, T]) IsRPCResp() bool

func (*Elem[CTX, T]) IsSingle

func (this_ *Elem[CTX, T]) IsSingle() bool

func (*Elem[CTX, T]) MsgName

func (this_ *Elem[CTX, T]) MsgName() string

func (*Elem[CTX, T]) ReqPool

func (this_ *Elem[CTX, T]) ReqPool() *sync.Pool

func (*Elem[CTX, T]) RespPool

func (this_ *Elem[CTX, T]) RespPool() *sync.Pool

func (*Elem[CTX, T]) String

func (this_ *Elem[CTX, T]) String() string

type HandleFunc

type HandleFunc[CTX ctx.IContextPtr[T], T any] func(ctx CTX) *berror.ErrMsg

type Handler

type Handler[CTX ctx.IContextPtr[T], T any] struct {
	// contains filtered or unexported fields
}

func NewHandler

func NewHandler[CTX ctx.IContextPtr[T], T any](middlewares ...MiddleWare[CTX, T]) *Handler[CTX, T]

NewHandler create Router Handler

func (*Handler[CTX, T]) GetBroadcastSubjInfo

func (h *Handler[CTX, T]) GetBroadcastSubjInfo() map[string]struct{}

GetBroadcastSubjInfo get all broadcast subj topic prefix

func (*Handler[CTX, T]) GetHandler

func (h *Handler[CTX, T]) GetHandler(msgName string) (*Elem[CTX, T], bool)

GetHandler get Elem by msgName or nil

func (*Handler[CTX, T]) GetQueueSubjInfo

func (h *Handler[CTX, T]) GetQueueSubjInfo() map[string]struct{}

GetQueueSubjInfo get all queue subj topic prefix

func (*Handler[CTX, T]) Group

func (h *Handler[CTX, T]) Group(middlewares ...MiddleWare[CTX, T]) *Handler[CTX, T]

Group create a new Handler with same base middlewares

func (*Handler[CTX, T]) Logger

func (h *Handler[CTX, T]) Logger()

type MiddleWare

type MiddleWare[CTX ctx.IContextPtr[T], T any] func(HandleFunc[CTX, T]) HandleFunc[CTX, T]