Confusing operator overload semantics for serialization/deserialization

[4x11]

Description

In libraries like Boost.Serialization, serialization and deserialization are defined using free functions (non-member functions) with intuitive parameter order:

// deserialise – read data from stream into object
auto& operator>>(auto& stream, MyStruct& myData);

// serialise – write data from object into stream
auto& operator<<(auto& stream, const MyStruct& myData);

This follows the natural left-to-right data flow:

stream >> myData; // data moves from stream to myData (deserialization)

stream << myData; // data moves from myData to stream (serialization)

Hexi uses member operator overloads instead:

struct MyData
{
    // deserialise
    auto& operator>>(auto& stream);
    
    // serialise
    auto& operator<<(auto& stream) const;
};

This creates counter-intuitive semantics. Because the operators are defined as member functions, the logical reading becomes confusing:

auto& MyStruct::operator>>(auto& stream) { /*...*/ }

Its naturally reads as "take data from MyStruct and write it to stream". However, this method actually performs deserialization - reading from the stream into the struct.

Proposed solutions

1. Use operator>> for serialization and operator<< for deserialization
2. Change the API to use free function overloads instead of member functions::

// deserialise
friend auto& operator>>(auto& stream, MyStruct& myData);

// serialise  
friend auto& operator<<(auto& stream, const MyStruct& myData);

[Chaosvex]

Thanks, I'll look into this.

[Chaosvex]

To add, the overloads are not something I ever use, so they probably need a little bit of love. This seems like a reasonable suggestion, so I'll investigate it at some point through the week.

There are a few other updates I need to apply to Hexi at some point in the near future, so perhaps I can get those done at the same time.