From 6eeedf40617681802a0400ca569208cebdb3684b Mon Sep 17 00:00:00 2001
From: azw <vcl_delphi@126.com>
Date: Wed, 16 Aug 2023 22:12:18 +0800
Subject: [PATCH] 1

---
 server/imserver/ss/ss.auto_gen.go | 162 ++++++++++++++++++++++++++++++
 1 file changed, 162 insertions(+)
 create mode 100644 server/imserver/ss/ss.auto_gen.go

diff --git a/server/imserver/ss/ss.auto_gen.go b/server/imserver/ss/ss.auto_gen.go
new file mode 100644
index 00000000..c9818852
--- /dev/null
+++ b/server/imserver/ss/ss.auto_gen.go
@@ -0,0 +1,162 @@
+package ss
+
+import (
+        "f5"
+        proto "github.com/golang/protobuf/proto"
+)
+
+type SsNetMsgHandler f5.NetMsgHandler[MsgHandler];
+
+type MsgHandlerImpl struct {
+}
+
+var handlers [2000]*SsNetMsgHandler
+
+func GetNetMsgHandler(msgId uint16) *SsNetMsgHandler {
+        handler := handlers[msgId]
+        return handler
+}
+
+func DispatchMsg(handler *SsNetMsgHandler, hdr *f5.MsgHdr, msgHandler MsgHandler) {
+        handler.Cb(hdr, msgHandler)
+}
+
+func RegHandlerId(msgId int, handlerId int) {
+        handler := handlers[msgId]
+        handler.HandlerId = handlerId
+}
+
+func ParsePb(msgId uint16, data []byte) interface{} {
+        handler := handlers[msgId]
+        if handler == nil {
+                return nil
+        }
+        return handler.ParseCb(data)
+}
+
+type MsgHandler interface {
+        SS_Ping(*f5.MsgHdr, *SS_Ping)
+        SS_Pong(*f5.MsgHdr, *SS_Pong)
+        SS_WSP_SocketDisconnect(*f5.MsgHdr, *SS_WSP_SocketDisconnect)
+        SS_WSP_RequestTargetServer(*f5.MsgHdr, *SS_WSP_RequestTargetServer)
+        SS_MS_ResponseTargetServer(*f5.MsgHdr, *SS_MS_ResponseTargetServer)
+        SS_ForceCloseSocket(*f5.MsgHdr, *SS_ForceCloseSocket)
+}
+
+func (this *MsgHandlerImpl) SS_Ping(hdr *f5.MsgHdr, msg *SS_Ping) {
+}
+
+func (this *MsgHandlerImpl) SS_Pong(hdr *f5.MsgHdr, msg *SS_Pong) {
+}
+
+func (this *MsgHandlerImpl) SS_WSP_SocketDisconnect(hdr *f5.MsgHdr, msg *SS_WSP_SocketDisconnect) {
+}
+
+func (this *MsgHandlerImpl) SS_WSP_RequestTargetServer(hdr *f5.MsgHdr, msg *SS_WSP_RequestTargetServer) {
+}
+
+func (this *MsgHandlerImpl) SS_MS_ResponseTargetServer(hdr *f5.MsgHdr, msg *SS_MS_ResponseTargetServer) {
+}
+
+func (this *MsgHandlerImpl) SS_ForceCloseSocket(hdr *f5.MsgHdr, msg *SS_ForceCloseSocket) {
+}
+
+func (this *SS_Ping) GetNetMsgId() uint16 {
+        return uint16(SSMessageIdE__SS_Ping)
+}
+
+func (this *SS_Pong) GetNetMsgId() uint16 {
+        return uint16(SSMessageIdE__SS_Pong)
+}
+
+func (this *SS_WSP_SocketDisconnect) GetNetMsgId() uint16 {
+        return uint16(SSMessageIdE__SS_WSP_SocketDisconnect)
+}
+
+func (this *SS_WSP_RequestTargetServer) GetNetMsgId() uint16 {
+        return uint16(SSMessageIdE__SS_WSP_RequestTargetServer)
+}
+
+func (this *SS_MS_ResponseTargetServer) GetNetMsgId() uint16 {
+        return uint16(SSMessageIdE__SS_MS_ResponseTargetServer)
+}
+
+func (this *SS_ForceCloseSocket) GetNetMsgId() uint16 {
+        return uint16(SSMessageIdE__SS_ForceCloseSocket)
+}
+
+func init() {
+
+        handlers[int(SSMessageIdE__SS_Ping)] = &SsNetMsgHandler{
+                MsgId: int(SSMessageIdE__SS_Ping),
+                ParseCb: func (data []byte) interface{} {
+                        msg := &SS_Ping{}
+                        proto.Unmarshal(data, msg)
+                        return msg
+                },
+                Cb: func (hdr *f5.MsgHdr, handler MsgHandler) {
+                        handler.SS_Ping(hdr, hdr.Msg.(*SS_Ping))
+                },
+        }
+
+        handlers[int(SSMessageIdE__SS_Pong)] = &SsNetMsgHandler{
+                MsgId: int(SSMessageIdE__SS_Pong),
+                ParseCb: func (data []byte) interface{} {
+                        msg := &SS_Pong{}
+                        proto.Unmarshal(data, msg)
+                        return msg
+                },
+                Cb: func (hdr *f5.MsgHdr, handler MsgHandler) {
+                        handler.SS_Pong(hdr, hdr.Msg.(*SS_Pong))
+                },
+        }
+
+        handlers[int(SSMessageIdE__SS_WSP_SocketDisconnect)] = &SsNetMsgHandler{
+                MsgId: int(SSMessageIdE__SS_WSP_SocketDisconnect),
+                ParseCb: func (data []byte) interface{} {
+                        msg := &SS_WSP_SocketDisconnect{}
+                        proto.Unmarshal(data, msg)
+                        return msg
+                },
+                Cb: func (hdr *f5.MsgHdr, handler MsgHandler) {
+                        handler.SS_WSP_SocketDisconnect(hdr, hdr.Msg.(*SS_WSP_SocketDisconnect))
+                },
+        }
+
+        handlers[int(SSMessageIdE__SS_WSP_RequestTargetServer)] = &SsNetMsgHandler{
+                MsgId: int(SSMessageIdE__SS_WSP_RequestTargetServer),
+                ParseCb: func (data []byte) interface{} {
+                        msg := &SS_WSP_RequestTargetServer{}
+                        proto.Unmarshal(data, msg)
+                        return msg
+                },
+                Cb: func (hdr *f5.MsgHdr, handler MsgHandler) {
+                        handler.SS_WSP_RequestTargetServer(hdr, hdr.Msg.(*SS_WSP_RequestTargetServer))
+                },
+        }
+
+        handlers[int(SSMessageIdE__SS_MS_ResponseTargetServer)] = &SsNetMsgHandler{
+                MsgId: int(SSMessageIdE__SS_MS_ResponseTargetServer),
+                ParseCb: func (data []byte) interface{} {
+                        msg := &SS_MS_ResponseTargetServer{}
+                        proto.Unmarshal(data, msg)
+                        return msg
+                },
+                Cb: func (hdr *f5.MsgHdr, handler MsgHandler) {
+                        handler.SS_MS_ResponseTargetServer(hdr, hdr.Msg.(*SS_MS_ResponseTargetServer))
+                },
+        }
+
+        handlers[int(SSMessageIdE__SS_ForceCloseSocket)] = &SsNetMsgHandler{
+                MsgId: int(SSMessageIdE__SS_ForceCloseSocket),
+                ParseCb: func (data []byte) interface{} {
+                        msg := &SS_ForceCloseSocket{}
+                        proto.Unmarshal(data, msg)
+                        return msg
+                },
+                Cb: func (hdr *f5.MsgHdr, handler MsgHandler) {
+                        handler.SS_ForceCloseSocket(hdr, hdr.Msg.(*SS_ForceCloseSocket))
+                },
+        }
+
+}
\ No newline at end of file