About edf.RegisterTypeOf

[Capybara-1]

Hello, I'm using the latest V310 branch. I'm using protobuf-generated structures for data transfer between remote nodes, but the protobuf-generated structures cannot be used in non-pointer form (it's impossible under my current project architecture).

I implemented BinaryMarshaler and BinaryUnmarshaler for the protobuf-generated structures, but I still can't use edf.RegisterTypeOf(value) because it internally blocks pointer parameters.

Is it possible to avoid intercepting pointer types, or are there any alternative solutions to handle this?

[halturin]

Could you show an example of how you’re using it? If a type implements BinaryMarshaler/BinaryUnmarshaler, RegisterTypeOf skips reflection, so the type can contain anything—private fields, pointers, and so on

[halturin]

btw, you may also want to try this one https://github.com/hashicorp/protoc-gen-go-binary to generate binary marshalers, and then just register those types using edf.RegisterTypeOf. should work.

[halturin]

please, provide more details. "doesn't work" doesn't tell enough.

[zylikedream]

I have a protobuf struct named ack defined in the image below.
When I attempt to register it using the code edf.RegisterTypeOf(&pb.Ack{}), an error is thrown with the message: "register pointer ack pointer type is not supported".
When I switch to using edf.RegisterTypeOf(pb.Ack{}) instead, another error occurs: "register ack struct Ack has unexported field(s)".
In other words, I am unable to register the pb.Ack struct successfully.

[halturin]

this is a common Go gotcha :) MarshalBinary should be on the value receiver

// MarshalBinary implements encoding.BinaryMarshaler
func (msg Ack) MarshalBinary ([byte, error) {
     return proto. Marshal(m: msg)
}
// UnmarshalBinary implements encoding.BinaryUnmarshaler
func (msg *Ack) UnmarshalBinary(b []byte) error {
    return proto.Unmarshal(b, m: msg)
}

but I'll add a workaround for this case

[halturin]

#238

[halturin]

#238 is closed, wont be implemented, see comment there

[Capybara-1]

my code is

when running

edf.Encode will return no support pointer

func _NewChatMessageModel() ChatMessageModel {
    return &_ChatMessage{
        Id:         0,
        Channel:    0,
        SubChannel: "",
        Sender:     0,
        Receiver:   0,
        SendTime:   0,
        Content:    "",
    }
}
type GeneralModel interface {


	MarshalBinary() (data []byte, err error)
	UnmarshalBinary(data []byte) error
}
type ChatMessageModel interface {
    GeneralModel 
}

type _ChatMessage struct {
    Id         int64        `bson:"id" json:"Id"`
    Channel    int64        `bson:"channel" json:"Channel"`
    SubChannel string       `bson:"sub_channel" json:"SubChannel"`
    Sender     int64        `bson:"sender" json:"Sender"`
    Receiver   int64        `bson:"receiver" json:"Receiver"`
    SendTime   int64        `bson:"send_time" json:"SendTime"`
    Content    string       `bson:"content" json:"Content"`
}

func (this _ChatMessage) MarshalBinary() ([]byte, error) { 
    return sonic.Marshal(this) 
}

func (this *_ChatMessage) UnmarshalBinary(binary []byte) error {
    if err := sonic.Unmarshal(binary, this); err != nil {
        return err
    }
    return nil
}

func main() {
    messageModel := _NewChatMessageModel().(*_ChatMessage )
    messageModel.Id = 111
 
    
    buffer := lib.TakeBuffer()
    err := edf.Encode(messageModel, buffer, edf.Options{})
    if err != nil {
        panic(err)
    }
    fmt.Println(buffer.B)
}

[halturin]

you are trying to encode messageModel which is a pointer to _ChatMessage

here is the fixed code

func main() {
    messageModel := _NewChatMessageModel().(*_ChatMessage )
    messageModel.Id = 111

    // register this type in EDF 
    edf.RegisterTypeOf(_ChatMessage{})

    buffer := lib.TakeBuffer()

    err := edf.Encode(*messageModel, buffer, edf.Options{})
    if err != nil {
        panic(err)
    }
    fmt.Println(buffer.B)
}

[halturin]

In this specific example, you don’t need to implement MarshalBinary or UnmarshalBinary, because the type contains neither pointers nor unexported (private) fields. All you need is just to encode the value instead of pointer to the value.

[Capybara-1]

In this specific example, you don’t need to implement MarshalBinary or UnmarshalBinary, because the type contains neither pointers nor unexported (private) fields. All you need is just to encode the value instead of pointer to the value.

This is just an example. In actual usage, we won't assert the concrete type but will expose the ChatMessageModel interface externally. Additionally, there are other pointer fields to structures within the struct.

[halturin]

just make sure you send a message (gen.Process.Send) or making a call request (gen.ProcessCall) using the value rather than the pointer. the message/request type has to be registered first using edf.RegisterTypeOf. For the types that having pointers/unexported fields the MarshalBinary/UnmarshalBinary interfaces have to be implemented. Thats it.