Refactor void handling: add specialized encoder/decoder/type logic, update void-based operations for clarity and correctness

nbt/nbt.go

@@ -34,7 +34,7 @@ type Anon struct {
 	Value any
 }
 
-func (s Anon) Decode(r io.Reader) (ret Anon, err error) {
+func (s *Anon) Decode(r io.Reader) (err error) {
 	id := int8(0)
 	err = binary.Read(r, Order, &id)
 	if err != nil {
@@ -44,11 +44,10 @@ func (s Anon) Decode(r io.Reader) (ret Anon, err error) {
 	if err != nil {
 		return
 	}
-	ret = s
 	return
 }
 
-func (s Anon) Encode(w io.Writer) (err error) {
+func (s *Anon) Encode(w io.Writer) (err error) {
 	id, err := getId(s.Value)
 	if err != nil {
 		return

proto_base/base_types.go

@@ -75,29 +75,20 @@ type PacketIdentifier struct {
 
 type (
 	ToDo       struct{}
-	Void       struct{}
 	RestBuffer []byte
 )
 
-func (v Void) Encode(_ io.Writer) (err error) {
-	return
-}
-
-func (v Void) Decode(_ io.Reader) (ret Void, err error) {
-	return
-}
-
 var ToDoError = errors.New("to do")
 var BadTypeError = errors.New("bad type")
 
-func (r RestBuffer) Encode(w io.Writer) (err error) {
+func (r *RestBuffer) Encode(w io.Writer) (err error) {
-	_, err = w.Write(r)
+	_, err = w.Write(*r)
 	return
 }
 
-func (RestBuffer) Decode(r io.Reader) (ret RestBuffer, err error) {
+func (ret *RestBuffer) Decode(r io.Reader) (err error) {
 	b, err := io.ReadAll(r)
-	ret = b
+	*ret = b
 	return
 }
 
@@ -215,7 +206,7 @@ func ErroringIndex[K comparable, V any, M map[K]V](m M, i K) (v V, err error) {
 	return
 }
 
-type EncodeDecodeAble[Self any] interface {
+type EncodeDecodeAble interface {
 	Encode(w io.Writer) (err error)
-	Decode(r io.Reader) (ret Self, err error)
+	Decode(r io.Reader) (err error)
 }

proto_generated/v1_21_8/helpers.go

@@ -1,9 +1,8 @@
 package v1_21_8
 
 import (
-	"io"
-
 	"github.com/admin-else/strom/proto_base"
+	"io"
 )
 
 func HandshakingToServerPacketIdentifierToType(s string) (t any) {
@@ -1205,7 +1204,7 @@ func DecodePacket(d proto_base.Direction, s proto_base.State, r io.Reader) (para
 			params = packet.Params
 		case proto_base.Play:
 			var packet PlayToServerPacket
-			packet, err = PlayToServerPacket{}.Decode(r)
+			packet, err = packet.Decode(r)
 			if err != nil {
 				return
 			}

proto_generator/main.go

@@ -226,8 +226,8 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error {
 		AppendDecl(g.File, TypeDecl(tName, e))
 
 		args := []NameAndType{{"r", Ident("io.Reader")}}
-		rets := []NameAndType{{"ret", Ident(tName)}, {"err", Ident("error")}}
+		rets := []NameAndType{{"err", Ident("error")}}
-		decodeFunction := NewFuncWithReceiver("Decode", "_", tName, args, rets)
+		decodeFunction := NewFuncWithReceiver("Decode", "ret", Pointer(Ident(tName)), args, rets)
 		g.Depth = 0
 		s, err := g.VisitDecoder(retExpr, v, tName)
 		if err != nil {
@@ -241,7 +241,7 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error {
 
 		args = []NameAndType{{"w", Ident("io.Writer")}}
 		rets = []NameAndType{{"err", Ident("error")}}
-		encodeFunction := NewFuncWithReceiver("Encode", "ret", tName, args, rets)
+		encodeFunction := NewFuncWithReceiver("Encode", "ret", Pointer(Ident(tName)), args, rets)
 		g.Depth = 0
 		s, err = g.VisitEncoder(retExpr, v, tName)
 		if err != nil {

proto_generator/native_decoder.go

@@ -12,7 +12,7 @@ import (
 func DefaultDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
 	s = Stmts(
 		Assign(
-			Exprs(varToSet, Ident("err")),
+			Exprs(Ident("err")),
 			Exprs(Call(SelectorExprAndStr(varToSet, "Decode"), Ident("r"))),
 		),
 		IfErrNil(),
@@ -511,6 +511,10 @@ func VarLongDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (
 	return
 }
 
+func VoidDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
+	return
+}
+
 func (g *Generator) RegisterDecoderNatives() {
 	g.DecoderNatives = map[string]FunctionGeneratorFunc{
 		"container": ContainerDecoder,
@@ -523,7 +527,7 @@ func (g *Generator) RegisterDecoderNatives() {
 		"bitfield":  BitFieldDecoder,
 		"string":    StringDecoder,
 
-		"void":            DefaultDecoder,
+		"void":            VoidDecoder,
 		"varint":          VarIntDecoder,
 		"varlong":         VarLongDecoder,
 		"anonymousNbt":    DefaultDecoder,

proto_generator/native_encoder.go

@@ -192,7 +192,11 @@ func SwitchEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s
 		if err != nil {
 			return
 		}
-		s1 := Define(Exprs(Ident(name), Ident("ok")), Exprs(TypeAssert(varToSet, tType)))
+		varName := name
+		if fType == "void" {
+			varName = "_"
+		}
+		s1 := Define(Exprs(Ident(varName), Ident("ok")), Exprs(TypeAssert(varToSet, tType)))
 		s2 := If(Not(Ident("ok")), NewBlockEllipsis(Assign121(Ident("err"), Selector("proto_base", "BadTypeError")), Return()))
 		var caseDecodeValueStmts []ast.Stmt
 		caseDecodeValueStmts, err = g.VisitEncoder(Ident(name), fType, name)
@@ -333,6 +337,10 @@ func VarLongEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (
 	return
 }
 
+func VoidEncoder(_ *Generator, _ ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
+	return
+}
+
 func (g *Generator) RegisterEncoderNatives() {
 	g.EncoderNatives = map[string]FunctionGeneratorFunc{
 		"container": ContainerEncoder,
@@ -344,7 +352,7 @@ func (g *Generator) RegisterEncoderNatives() {
 		"buffer":    BufferEncoder,
 		"bitfield":  BitFieldEncoder,
 
-		"void":            DefaultEncoder,
+		"void":            VoidEncoder,
 		"varint":          VarIntEncoder,
 		"varlong":         VarLongEncoder,
 		"anonymousNbt":    DefaultEncoder,

proto_generator/native_type.go

@@ -153,6 +153,11 @@ func MakeSelectorVisitor(x, sel string) func(g *Generator, dataRaw any) (e ast.E
 	}
 }
 
+func VoidType(_ *Generator, _ any) (e ast.Expr, err error) {
+	e = NewStruct()
+	return
+}
+
 func (g *Generator) RegisterNatives() {
 	g.Natives = map[string]ExprGeneratorFunc{
 		"container":                VisitContainerType,
@@ -164,7 +169,7 @@ func (g *Generator) RegisterNatives() {
 		"native":                   VisitDontGenerateType,
 		"anonymousNbt":             MakeSelectorVisitor("nbt", "Anon"),
 		"anonOptionalNbt":          MakeSelectorVisitor("nbt", "Anon"), // I have no idea what the difference is between these two
-		"void":                     MakeSelectorVisitor("proto_base", "Void"),
+		"void":                     VoidType,
 		"bool":                     MakeIdentVisitor("bool"),
 		"u8":                       MakeIdentVisitor("uint8"),
 		"u16":                      MakeIdentVisitor("uint16"),

proto_generator/printer.go

@@ -269,13 +269,13 @@ func NewFunc(name string, arguments []NameAndType, returns []NameAndType) *ast.F
 	}
 }
 
-func NewFuncWithReceiver(name, receiverName, receiver string, arguments []NameAndType, returns []NameAndType) *ast.FuncDecl {
+func NewFuncWithReceiver(name, receiverName string, receiver ast.Expr, arguments []NameAndType, returns []NameAndType) *ast.FuncDecl {
 	f := NewFunc(name, arguments, returns)
 	f.Recv = &ast.FieldList{
 		List: []*ast.Field{
 			{
 				Names: []*ast.Ident{{Name: receiverName}},
-				Type:  &ast.Ident{Name: receiver},
+				Type:  receiver,
 			},
 		},
 	}

tools/uncodeable_packet_hunter_proxy/main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
+	"github.com/admin-else/strom/proto_generated"
 	"github.com/admin-else/strom/proto_generated/v1_21_8"
 	"github.com/admin-else/strom/server"
 	"github.com/admin-else/strom/server/server_modules"
@@ -21,8 +22,8 @@ type ProxyClient struct {
 	Server *Proxy
 }
 
-func (p *ProxyClient) Default(event any) (err error) {
+func (p *ProxyClient) OnDefault(event event.Default) (err error) {
-	err = p.Server.Send(event)
+	err = p.Server.Send(event.Val)
 	return
 }
 
@@ -34,8 +35,8 @@ func (p *ProxyClient) OnStart(_ event.OnStart) (err error) {
 	return
 }
 
-func (p *ProxyClient) OnUncodeable(packet proto.UnCodablePacket) (err error) {
+func (p *ProxyClient) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
-	err = p.Default(packet)
+	err = p.OnDefault(event.Default{Val: packet})
 	if err != nil {
 		return
 	}
@@ -71,7 +72,7 @@ func (p *Proxy) OnFinishConfiguration(packet v1_21_8.ConfigurationToServerPacket
 	return
 }
 
-func (p *Proxy) OnUncodeable(packet proto.UnCodablePacket) (err error) {
+func (p *Proxy) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
 	err = p.Default(packet)
 	if err != nil {
 		return
@@ -117,7 +118,7 @@ func SaveUnCodeAbleAsTest(d proto_base.Direction, packet proto.UnCodablePacket)
 
 var StatusResponse = server_modules.StatusResponse{Description: struct {
 	Text string `json:"text"`
-}{Text: "Uncodeable packet hunter proxy"}, Version: struct {
+}{Text: "Un-code-able packet hunter proxy"}, Version: struct {
 	Name     string `json:"name"`
 	Protocol int    `json:"protocol"`
 }{Name: "STROM", Protocol: 772}}
@@ -143,10 +144,10 @@ func main() {
 		defer pc.Close()
 		defer p.Close()
 		go func() {
-			errChan <- pc.Start(pc)
+			errChan <- pc.StartOne(pc)
 		}()
 		go func() {
-			errChan <- p.Start(p)
+			errChan <- p.StartOne(p)
 		}()
 		err = <-errChan
 		return