examples: Regenerate protocol files

examples/chat/protocol.go

@@ -57,6 +57,25 @@ func boolInt(input bool) int {
 // ensure ucontainer is always imported
 var _ hopp.Option[int]
 
+// ReceivedMessage is a sealed interface representing the value of a
+// message in this package. To determine what kind of message it is,
+// use a type switch like this:
+// 
+//   switch message := message.(type) {
+//   case MessageError:
+//           doSomething()
+//   case MessageSuccess:
+//           doSomething()
+//   case MessageJoin:
+//           doSomething()
+// 
+//   ...
+// 
+//   }
+type ReceivedMessage interface {
+	isReceivedMessage()
+}
+
 // Error is sent by a party when the other party has done something erroneous. The
 // valid error codes are:
 // 
@@ -84,29 +103,29 @@ func(this *MessageError) Encode(encoder *tape.Encoder) (n int, err error) {
 	nn, err = encoder.WriteUintN(2, tag_1.CN() + 1)
 	n += nn; if err != nil { return n, err }
 	{
+		nn, err = encoder.WriteUint16(0x0000)
+		n += nn; if err != nil { return n, err }
+		tag_2 := tape.LI.WithCN(1)
+		nn, err = encoder.WriteUint8(uint8(tag_2))
+		n += nn; if err != nil { return n, err }
+		nn, err = encoder.WriteUint16(uint16((*this).Code))
+		n += nn; if err != nil { return n, err }
 		if value, ok := (*this).Description.Value(); ok {
 			nn, err = encoder.WriteUint16(0x0001)
 			n += nn; if err != nil { return n, err }
-			tag_2 := tape.StringTag(string(value))
+			tag_3 := tape.StringTag(string(value))
-			nn, err = encoder.WriteUint8(uint8(tag_2))
+			nn, err = encoder.WriteUint8(uint8(tag_3))
 			n += nn; if err != nil { return n, err }
 			if len(value) > tape.MaxStructureLength {
 				return n, tape.ErrTooLong
 			}
-			if tag_2.Is(tape.LBA) {
+			if tag_3.Is(tape.LBA) {
-				nn, err = encoder.WriteUintN(uint64(len(value)), tag_2.CN())
+				nn, err = encoder.WriteUintN(uint64(len(value)), tag_3.CN())
 				n += nn; if err != nil { return n, err }
 			}
 			nn, err = encoder.Write([]byte(value))
 			n += nn; if err != nil { return n, err }
 		}
-		nn, err = encoder.WriteUint16(0x0000)
-		n += nn; if err != nil { return n, err }
-		tag_3 := tape.LI.WithCN(1)
-		nn, err = encoder.WriteUint8(uint8(tag_3))
-		n += nn; if err != nil { return n, err }
-		nn, err = encoder.WriteUint16(uint16((*this).Code))
-		n += nn; if err != nil { return n, err }
 	}
 	return n, nil
 }
@@ -124,6 +143,7 @@ func(this *MessageError) Decode(decoder *tape.Decoder) (n int, err error) {
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
+func (this MessageError) isReceivedMessage() { }
 
 // Success is sent by a party when it has successfully completed a task given to it
 // by the other party. The sending party must immediately close the transaction
@@ -162,6 +182,7 @@ func(this *MessageSuccess) Decode(decoder *tape.Decoder) (n int, err error) {
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
+func (this MessageSuccess) isReceivedMessage() { }
 
 // Join is sent by the client when it wishes to join a room. It must begin a new
 // transaction, and that transaction will persist while the user is in that room.
@@ -231,6 +252,7 @@ func(this *MessageJoin) Decode(decoder *tape.Decoder) (n int, err error) {
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
+func (this MessageJoin) isReceivedMessage() { }
 
 // Chat is sent by the client when it wishes to post a message to the room. It is
 // also relayed by the server to other clients to notify them of the message. It
@@ -299,6 +321,7 @@ func(this *MessageChat) Decode(decoder *tape.Decoder) (n int, err error) {
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
+func (this MessageChat) isReceivedMessage() { }
 
 // JoinNotify is sent by the server when another client joins the room. It must be
 // sent within a room transaction.
@@ -351,6 +374,7 @@ func(this *MessageJoinNotify) Decode(decoder *tape.Decoder) (n int, err error) {
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
+func (this MessageJoinNotify) isReceivedMessage() { }
 
 // LeaveNotify is sent by the server when another client leaves the room. It must
 // be sent within a room transaction.
@@ -403,6 +427,7 @@ func(this *MessageLeaveNotify) Decode(decoder *tape.Decoder) (n int, err error)
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
+func (this MessageLeaveNotify) isReceivedMessage() { }
 
 func decodeBranch_1d505103df99c95e6bed0800d0ea881a_MessageError(this *MessageError, decoder *tape.Decoder, tag tape.Tag) (n int, err error) {
 	var nn int
@@ -693,21 +718,11 @@ func decodeBranch_68c536511e6d598462efc482144438e9_MessageLeaveNotify(this *Mess
 
 // Receive decodes a message from a transaction and returns it as a value.
 // Use a type switch to determine what type of message it is.
-func Receive(trans hopp.Trans) (message any, n int, err error) {
+func Receive(trans hopp.Trans) (message ReceivedMessage, n int, err error) {
 	method, reader, err := trans.ReceiveReader()
-	decoder := tape.NewDecoder(reader)
 	if err != nil { return nil, n, err }
+	decoder := tape.NewDecoder(reader)
 	switch method {
-	case 0x0401:
-		var message MessageLeaveNotify
-		nn, err := message.Decode(decoder)
-		n += nn; if err != nil { return nil, n, err }
-		return message, n, nil
-	case 0x0000:
-		var message MessageError
-		nn, err := message.Decode(decoder)
-		n += nn; if err != nil { return nil, n, err }
-		return message, n, nil
 	case 0x0001:
 		var message MessageSuccess
 		nn, err := message.Decode(decoder)
@@ -728,6 +743,16 @@ func Receive(trans hopp.Trans) (message any, n int, err error) {
 		nn, err := message.Decode(decoder)
 		n += nn; if err != nil { return nil, n, err }
 		return message, n, nil
+	case 0x0401:
+		var message MessageLeaveNotify
+		nn, err := message.Decode(decoder)
+		n += nn; if err != nil { return nil, n, err }
+		return message, n, nil
+	case 0x0000:
+		var message MessageError
+		nn, err := message.Decode(decoder)
+		n += nn; if err != nil { return nil, n, err }
+		return message, n, nil
 	}
 	return nil, n, fmt.Errorf("%w: M%04X", hopp.ErrUnknownMethod, method)
 }

examples/ping/protocol.go

@@ -57,6 +57,20 @@ func boolInt(input bool) int {
 // ensure ucontainer is always imported
 var _ hopp.Option[int]
 
+// ReceivedMessage is a sealed interface representing the value of a
+// message in this package. To determine what kind of message it is,
+// use a type switch like this:
+// 
+//   switch message := message.(type) {
+//   case MessagePing:
+//           doSomething()
+//   case MessagePong:
+//           doSomething()
+//   }
+type ReceivedMessage interface {
+	isReceivedMessage()
+}
+
 // Ping is sent by the client to the server. It may contain any number. This
 // number will be returned to the client via a [Pong] message.
 type MessagePing int32
@@ -88,6 +102,7 @@ func(this *MessagePing) Decode(decoder *tape.Decoder) (n int, err error) {
 	*this = MessagePing(destination_2)
 	return n, nil
 }
+func (this MessagePing) isReceivedMessage() { }
 
 // Pong is sent by the server to the client in response to a [Ping] message, It
 // will contain the same number as that message.
@@ -120,10 +135,11 @@ func(this *MessagePong) Decode(decoder *tape.Decoder) (n int, err error) {
 	*this = MessagePong(destination_4)
 	return n, nil
 }
+func (this MessagePong) isReceivedMessage() { }
 
 // Receive decodes a message from a transaction and returns it as a value.
 // Use a type switch to determine what type of message it is.
-func Receive(trans hopp.Trans) (message any, n int, err error) {
+func Receive(trans hopp.Trans) (message ReceivedMessage, n int, err error) {
 	method, reader, err := trans.ReceiveReader()
 	if err != nil { return nil, n, err }
 	decoder := tape.NewDecoder(reader)