Be explicit with naming

Author: emilk

crates/store/re_log_encoding/src/decoder/mod.rs

@@ -142,7 +142,7 @@ pub fn options_from_bytes(bytes: &[u8]) -> Result<(CrateVersion, EncodingOptions
     warn_on_version_mismatch(version);
 
     match options.serializer {
-        Serializer::MsgPack | Serializer::Protobuf => {}
+        Serializer::LegacyMsgPack | Serializer::Protobuf => {}
     }
 
     Ok((CrateVersion::from_bytes(version), options))
@@ -323,7 +323,7 @@ impl<R: std::io::Read> Iterator for Decoder<R> {
                     _ => return Some(Err(err)),
                 },
             },
-            Serializer::MsgPack => {
+            Serializer::LegacyMsgPack => {
                 let header = match LegacyMessageHeader::decode(&mut self.read) {
                     Ok(header) => header,
                     Err(err) => match err {

crates/store/re_log_encoding/src/decoder/stream.rs

@@ -110,7 +110,7 @@ impl StreamDecoder {
                     self.options = options;
 
                     match self.options.serializer {
-                        Serializer::MsgPack => self.state = State::MsgPackMessageHeader,
+                        Serializer::LegacyMsgPack => self.state = State::MsgPackMessageHeader,
                         Serializer::Protobuf => self.state = State::ProtobufMessageHeader,
                     }
 

crates/store/re_log_encoding/src/decoder/streaming.rs

@@ -187,7 +187,7 @@ impl<R: AsyncBufRead + Unpin> Stream for StreamingDecoder<R> {
             }
 
             let (msg, processed_length) = match serializer {
-                crate::Serializer::MsgPack => {
+                crate::Serializer::LegacyMsgPack => {
                     let header_size = super::LegacyMessageHeader::SIZE;
                     if unprocessed_bytes.len() < header_size {
                         // Not enough data to read the header, need to wait for more

crates/store/re_log_encoding/src/encoder.rs

@@ -1,15 +1,17 @@
 //! Encoding of [`LogMsg`]es as a binary stream, e.g. to store in an `.rrd` file, or send over network.
 
-use crate::codec;
-use crate::codec::file::{self, encoder};
-use crate::FileHeader;
-use crate::LegacyMessageHeader;
-use crate::Serializer;
-use crate::{Compression, EncodingOptions};
 use re_build_info::CrateVersion;
 use re_chunk::{ChunkError, ChunkResult};
 use re_log_types::LogMsg;
 
+use crate::{
+    codec::{
+        self,
+        file::{self, encoder},
+    },
+    Compression, EncodingOptions, FileHeader, Serializer,
+};
+
 // ----------------------------------------------------------------------------
 
 /// On failure to encode or serialize a [`LogMsg`].
@@ -161,7 +163,7 @@ impl<W: std::io::Write> Encoder<W> {
                     .map(|_| self.scratch.len() as _)
                     .map_err(EncodeError::Write)
             }
-            Serializer::MsgPack => Err(EncodeError::CannotEncodeWithMsgPack),
+            Serializer::LegacyMsgPack => Err(EncodeError::CannotEncodeWithMsgPack),
         }
     }
 
@@ -170,7 +172,7 @@ impl<W: std::io::Write> Encoder<W> {
     #[inline]
     pub fn finish(&mut self) -> Result<(), EncodeError> {
         match self.serializer {
-            Serializer::MsgPack => {
+            Serializer::LegacyMsgPack => {
                 return Err(EncodeError::CannotEncodeWithMsgPack);
             }
             Serializer::Protobuf => {

crates/store/re_log_encoding/src/lib.rs

@@ -50,7 +50,9 @@ pub enum Compression {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[repr(u8)]
 pub enum Serializer {
-    MsgPack = 1,
+    /// For Rerun 0.22 and earlier. Only used to support loading old files.
+    LegacyMsgPack = 1,
+
     Protobuf = 2,
 }
 
@@ -79,7 +81,7 @@ impl EncodingOptions {
                     _ => return Err(OptionsError::UnknownCompression(compression)),
                 };
                 let serializer = match serializer {
-                    1 => Serializer::MsgPack,
+                    1 => Serializer::LegacyMsgPack,
                     2 => Serializer::Protobuf,
                     _ => return Err(OptionsError::UnknownSerializer(serializer)),
                 };
@@ -112,12 +114,6 @@ pub enum OptionsError {
     #[error("Unknown compression: {0}")]
     UnknownCompression(u8),
 
-    // TODO(jan): Remove this at some point, realistically 1-2 releases after 0.23
-    #[error(
-        "You are trying to load an old .rrd file that's not supported by this version of Rerun."
-    )]
-    RemovedMsgPackSerializer,
-
     #[error("Unknown serializer: {0}")]
     UnknownSerializer(u8),
 }