Some tools, I frequently use.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

157 lines
3.2 KiB

package nhooyrioWebsocketAddons
import (
"context"
"encoding/json"
"nhooyr.io/websocket"
"nhooyr.io/websocket/wsjson"
)
type GosmContainerSection struct {
TagID string `json:"tagid"`
Attribute string `json:"attribute"` // might left empty
Content string `json:"content"`
}
type GosmContainer []GosmContainerSection
type GosmBuffer []byte
type GosmAdapter interface {
//Revalue(...interface{}) (interface{}, error)
Convert() (GosmAdapter, error)
//WsCommunicator(method string, ctx context.Context, conn *websocket.Conn) (GosmAdapter, error)
}
func (r GosmContainer) Convert() (GosmAdapter, error) {
buffer, err := json.Marshal(r)
if err != nil {
panic(err)
}
return GosmBuffer(buffer), err
}
func (r GosmBuffer) Convert() (i GosmAdapter, err error) {
var gosm GosmContainer
err = json.Unmarshal(r, &gosm)
i = gosm
return
}
/*
func (r GosmContainer) WsCommunicator(method string, ctx context.Context, conn *websocket.Conn) (GosmAdapter, error) {
switch method {
case "json":
WsjsonSend(ctx, conn)
case "bytes":
WsSend()
default:
panic("Wrong communicator method")
}
return GosmBuffer{}, nil
}
func (r GosmBuffer) WsCommunicator(method string, ctx context.Context, conn *websocket.Conn) (GosmAdapter, error) {
switch method {
case "json":
WsjsonReceive()
case "bytes":
WsReceive()
default:
panic("Wrong communicator method")
}
return GosmContainer{}, nil
}
*/
func WsjsonSend(ctx context.Context, conn *websocket.Conn, sendval interface{}) (err error, receiveval interface{}) {
err = nil
//Send
err = wsjson.Write(ctx, conn, sendval)
if err != nil {
return err, nil
}
//Receive
err = wsjson.Read(ctx, conn, &receiveval)
if err != nil {
return err, nil
}
return
}
func WsjsonReceive(ctx context.Context, conn *websocket.Conn, dosth func(interface{}) interface{}) (err error, receiveval interface{}) {
var sendval interface{}
err = nil
//Receive
err = wsjson.Read(ctx, conn, &receiveval)
if err != nil {
return
}
if dosth != nil {
sendval = dosth(receiveval)
} else {
sendval = "" //It doesn't make sense to return unprocess receiveval
}
//Send
err = wsjson.Write(ctx, conn, sendval.(string))
if err != nil {
return
}
return
}
func WsSend(ctx context.Context, conn *websocket.Conn, sendval []byte, mts websocket.MessageType) (err error, receiveval []byte) {
var mtr websocket.MessageType
err = nil
//Send
err = conn.Write(ctx, mts, sendval)
if err != nil {
return err, nil
}
//Receive
mtr, receiveval, err = conn.Read(ctx)
if err != nil {
return err, nil
}
if mtr != mts { //Dürfte eigentlich niemals eintreten, denn MessageType mtr und mts sind identisch, sofern auf der anderen Seite WsReceive lauscht.
panic("websocket.MessageType inconsistency")
}
return
}
func WsReceive(ctx context.Context, conn *websocket.Conn, dosth func([]byte) []byte) (err error, receiveval []byte, mtr websocket.MessageType) {
var sendval []byte
err = nil
//Receive
mtr, receiveval, err = conn.Read(ctx)
if err != nil {
return
}
if dosth != nil {
sendval = dosth(receiveval)
} else {
sendval = []byte{} //It doesn't make sense to return unprocess receiveval
}
//Send
err = conn.Write(ctx, mtr, sendval)
if err != nil {
return
}
return
}