WIP

crates/items_2/src/binning/container_bins.rs

@@ -450,7 +450,7 @@ impl<EVT> ToJsonResult for ContainerBinsCollectorOutput<EVT>
 where
     EVT: EventValueType,
 {
-    fn to_json_value(&self) -> Result<serde_json::Value, err::Error> {
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
         let bins = &self.bins;
         let ts1sns: Vec<_> = bins.ts1s.iter().map(|x| x.ns()).collect();
         let ts2sns: Vec<_> = bins.ts2s.iter().map(|x| x.ns()).collect();
@@ -471,8 +471,7 @@ where
             maxs,
             avgs,
         };
-        let ret = serde_json::to_value(&val).map_err(err::Error::from_string);
-        ret
+        serde_json::to_value(&val)
     }
 }
 

crates/items_2/src/binsdim0.rs

@@ -731,8 +731,8 @@ impl<NTY> BinsDim0CollectedResult<NTY> {
 }
 
 impl<NTY: ScalarOps> ToJsonResult for BinsDim0CollectedResult<NTY> {
-    fn to_json_value(&self) -> Result<serde_json::Value, Error> {
-        serde_json::to_value(self).map_err(Error::from_string)
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self)
     }
 }
 

crates/items_2/src/binsxbindim0.rs

@@ -361,8 +361,8 @@ impl<NTY> BinsXbinDim0CollectedResult<NTY> {
 }
 
 impl<NTY: ScalarOps> ToJsonResult for BinsXbinDim0CollectedResult<NTY> {
-    fn to_json_value(&self) -> Result<serde_json::Value, Error> {
-        serde_json::to_value(self).map_err(Error::from_string)
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self)
     }
 }
 

crates/items_2/src/channelevents.rs

@@ -1023,8 +1023,8 @@ impl WithLen for ChannelEventsCollectorOutput {
 }
 
 impl items_0::collect_s::ToJsonResult for ChannelEventsCollectorOutput {
-    fn to_json_value(&self) -> Result<serde_json::Value, ::err::Error> {
-        serde_json::to_value(self).map_err(::err::Error::from_string)
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self)
     }
 }
 

crates/items_2/src/eventsdim0.rs

@@ -371,8 +371,8 @@ impl<STY: ScalarOps> WithLen for EventsDim0CollectorOutput<STY> {
 }
 
 impl<STY: ScalarOps> ToJsonResult for EventsDim0CollectorOutput<STY> {
-    fn to_json_value(&self) -> Result<serde_json::Value, Error> {
-        serde_json::to_value(self).map_err(Error::from_string)
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self)
     }
 }
 

crates/items_2/src/eventsdim0enum.rs

@@ -120,7 +120,7 @@ impl TypeName for EventsDim0EnumCollectorOutput {
 }
 
 impl ToJsonResult for EventsDim0EnumCollectorOutput {
-    fn to_json_value(&self) -> Result<serde_json::Value, Error> {
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
         todo!()
     }
 }

crates/items_2/src/eventsdim1.rs

@@ -334,8 +334,8 @@ impl<STY: ScalarOps> WithLen for EventsDim1CollectorOutput<STY> {
 }
 
 impl<STY: ScalarOps> ToJsonResult for EventsDim1CollectorOutput<STY> {
-    fn to_json_value(&self) -> Result<serde_json::Value, Error> {
-        serde_json::to_value(self).map_err(Error::from_string)
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self)
     }
 }
 

crates/items_2/src/eventsxbindim0.rs

@@ -652,8 +652,8 @@ impl<NTY> ToJsonResult for EventsXbinDim0CollectorOutput<NTY>
 where
     NTY: ScalarOps,
 {
-    fn to_json_value(&self) -> Result<serde_json::Value, Error> {
-        serde_json::to_value(self).map_err(Error::from_string)
+    fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self)
     }
 }
 

crates/items_2/src/framable.rs

@@ -4,7 +4,6 @@ use crate::frame::make_log_frame;
 use crate::frame::make_range_complete_frame;
 use crate::frame::make_stats_frame;
 use bytes::BytesMut;
-use err::Error;
 use items_0::framable::FrameTypeInnerDyn;
 use items_0::framable::FrameTypeInnerStatic;
 use items_0::streamitem::LogItem;
@@ -26,6 +25,27 @@ pub const INMEM_FRAME_HEAD: usize = 20;
 pub const INMEM_FRAME_FOOT: usize = 4;
 pub const INMEM_FRAME_MAGIC: u32 = 0xc6c3b73d;
 
+#[derive(Debug, thiserror::Error)]
+#[cstm(name = "ItemFramable")]
+pub enum Error {
+    Msg(String),
+    DummyError,
+    Frame(#[from] crate::frame::Error),
+}
+
+struct ErrMsg<E>(E)
+where
+    E: ToString;
+
+impl<E> From<ErrMsg<E>> for Error
+where
+    E: ToString,
+{
+    fn from(value: ErrMsg<E>) -> Self {
+        Self::Msg(value.0.to_string())
+    }
+}
+
 pub trait FrameTypeStatic {
     const FRAME_TYPE_ID: u32;
 }
@@ -78,14 +98,16 @@ where
         match self {
             Ok(StreamItem::DataItem(RangeCompletableItem::Data(k))) => {
                 let frame_type_id = k.frame_type_id();
-                make_frame_2(self, frame_type_id)
+                make_frame_2(self, frame_type_id).map_err(Error::from)
             }
-            Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete)) => make_range_complete_frame(),
-            Ok(StreamItem::Log(item)) => make_log_frame(item),
-            Ok(StreamItem::Stats(item)) => make_stats_frame(item),
+            Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete)) => {
+                make_range_complete_frame().map_err(Error::from)
+            }
+            Ok(StreamItem::Log(item)) => make_log_frame(item).map_err(Error::from),
+            Ok(StreamItem::Stats(item)) => make_stats_frame(item).map_err(Error::from),
             Err(e) => {
                 info!("calling make_error_frame for [[{e}]]");
-                make_error_frame(e)
+                make_error_frame(e).map_err(Error::from)
             }
         }
     }
@@ -186,7 +208,7 @@ fn test_frame_log() {
 fn test_frame_error() {
     use crate::channelevents::ChannelEvents;
     use crate::frame::json_from_slice;
-    let item: Sitemty<ChannelEvents> = Err(Error::with_msg_no_trace(format!("dummy-error-message")));
+    let item: Sitemty<ChannelEvents> = items_0::streamitem::sitem_err_from_string("dummyerror");
     let buf = Framable::make_frame_dyn(&item).unwrap();
     let len = u32::from_le_bytes(buf[12..16].try_into().unwrap());
     let tyid = u32::from_le_bytes(buf[8..12].try_into().unwrap());
@@ -194,5 +216,5 @@ fn test_frame_error() {
         panic!("bad tyid");
     }
     eprintln!("buf len {}  len {}", buf.len(), len);
-    let item2: Error = json_from_slice(&buf[20..20 + len as usize]).unwrap();
+    let item2: items_0::streamitem::SitemErrTy = json_from_slice(&buf[20..20 + len as usize]).unwrap();
 }

crates/items_2/src/frame.rs

@@ -13,7 +13,6 @@ use bincode::config::WithOtherTrailing;
 use bincode::DefaultOptions;
 use bytes::BufMut;
 use bytes::BytesMut;
-use err::Error;
 use items_0::bincode;
 use items_0::streamitem::LogItem;
 use items_0::streamitem::StatsItem;
@@ -27,6 +26,37 @@ use serde::Serialize;
 use std::any;
 use std::io;
 
+#[derive(Debug, thiserror::Error)]
+#[cstm(name = "ItemFrame")]
+pub enum Error {
+    TooLongPayload(usize),
+    UnknownEncoder(u32),
+    #[error("BufferMismatch({0}, {1}, {2})")]
+    BufferMismatch(u32, usize, u32),
+    #[error("TyIdMismatch({0}, {1})")]
+    TyIdMismatch(u32, u32),
+    Msg(String),
+    Bincode(#[from] Box<bincode::ErrorKind>),
+    RmpEnc(#[from] rmp_serde::encode::Error),
+    RmpDec(#[from] rmp_serde::decode::Error),
+    ErasedSerde(#[from] erased_serde::Error),
+    Postcard(#[from] postcard::Error),
+    SerdeJson(#[from] serde_json::Error),
+}
+
+struct ErrMsg<E>(E)
+where
+    E: ToString;
+
+impl<E> From<ErrMsg<E>> for Error
+where
+    E: ToString,
+{
+    fn from(value: ErrMsg<E>) -> Self {
+        Self::Msg(value.0.to_string())
+    }
+}
+
 pub fn bincode_ser<W>(
     w: W,
 ) -> bincode::Serializer<
@@ -54,7 +84,7 @@ where
 {
     let mut out = Vec::new();
     let mut ser = bincode_ser(&mut out);
-    item.serialize(&mut ser).map_err(|e| format!("{e}"))?;
+    item.serialize(&mut ser)?;
     Ok(out)
 }
 
@@ -68,14 +98,14 @@ where
         .with_fixint_encoding()
         .reject_trailing_bytes();
     let mut de = bincode::Deserializer::from_slice(buf, opts);
-    <T as serde::Deserialize>::deserialize(&mut de).map_err(|e| format!("{e}").into())
+    <T as serde::Deserialize>::deserialize(&mut de).map_err(Into::into)
 }
 
 fn msgpack_to_vec<T>(item: T) -> Result<Vec<u8>, Error>
 where
     T: Serialize,
 {
-    rmp_serde::to_vec_named(&item).map_err(|e| format!("{e}").into())
+    rmp_serde::to_vec_named(&item).map_err(Error::from)
 }
 
 fn msgpack_erased_to_vec<T>(item: T) -> Result<Vec<u8>, Error>
@@ -86,8 +116,7 @@ where
     {
         let mut ser1 = rmp_serde::Serializer::new(&mut out).with_struct_map();
         let mut ser2 = <dyn erased_serde::Serializer>::erase(&mut ser1);
-        item.erased_serialize(&mut ser2)
-            .map_err(|e| Error::from(format!("{e}")))?;
+        item.erased_serialize(&mut ser2)?;
     }
     Ok(out)
 }
@@ -96,14 +125,14 @@ fn msgpack_from_slice<T>(buf: &[u8]) -> Result<T, Error>
 where
     T: for<'de> serde::Deserialize<'de>,
 {
-    rmp_serde::from_slice(buf).map_err(|e| format!("{e}").into())
+    rmp_serde::from_slice(buf).map_err(Error::from)
 }
 
 fn postcard_to_vec<T>(item: T) -> Result<Vec<u8>, Error>
 where
     T: Serialize,
 {
-    postcard::to_stdvec(&item).map_err(|e| format!("{e}").into())
+    postcard::to_stdvec(&item).map_err(Error::from)
 }
 
 fn postcard_erased_to_vec<T>(item: T) -> Result<Vec<u8>, Error>
@@ -117,31 +146,30 @@ where
     {
         let mut ser2 = <dyn erased_serde::Serializer>::erase(&mut ser1);
         item.erased_serialize(&mut ser2)
-    }
-    .map_err(|e| Error::from(format!("{e}")))?;
-    let ret = ser1.output.finalize().map_err(|e| format!("{e}").into());
-    ret
+    }?;
+    let ret = ser1.output.finalize()?;
+    Ok(ret)
 }
 
 pub fn postcard_from_slice<T>(buf: &[u8]) -> Result<T, Error>
 where
     T: for<'de> serde::Deserialize<'de>,
 {
-    postcard::from_bytes(buf).map_err(|e| format!("{e}").into())
+    Ok(postcard::from_bytes(buf)?)
 }
 
 fn json_to_vec<T>(item: T) -> Result<Vec<u8>, Error>
 where
     T: Serialize,
 {
-    serde_json::to_vec(&item).map_err(Error::from_string)
+    Ok(serde_json::to_vec(&item)?)
 }
 
 pub fn json_from_slice<T>(buf: &[u8]) -> Result<T, Error>
 where
     T: for<'de> serde::Deserialize<'de>,
 {
-    serde_json::from_slice(buf).map_err(Error::from_string)
+    Ok(serde_json::from_slice(buf)?)
 }
 
 pub fn encode_to_vec<T>(item: T) -> Result<Vec<u8>, Error>
@@ -187,7 +215,7 @@ where
 {
     let enc = encode_erased_to_vec(item)?;
     if enc.len() > u32::MAX as usize {
-        return Err(Error::with_msg(format!("too long payload {}", enc.len())));
+        return Err(Error::TooLongPayload(enc.len()));
     }
     let mut h = crc32fast::Hasher::new();
     h.update(&enc);
@@ -323,15 +351,10 @@ where
     T: FrameDecodable,
 {
     if frame.encid() != INMEM_FRAME_ENCID {
-        return Err(Error::with_msg(format!("unknown encoder id {:?}", frame)));
+        return Err(Error::UnknownEncoder(frame.encid()));
     }
     if frame.len() as usize != frame.buf().len() {
-        return Err(Error::with_msg(format!(
-            "buf mismatch  {}  vs  {}  in {:?}",
-            frame.len(),
-            frame.buf().len(),
-            frame
-        )));
+        return Err(Error::BufferMismatch(frame.len(), frame.buf().len(), frame.tyid()));
     }
     if frame.tyid() == ERROR_FRAME_TYPE_ID {
         // error frames are always encoded as json
@@ -376,12 +399,7 @@ where
     } else {
         let tyid = T::FRAME_TYPE_ID;
         if frame.tyid() != tyid {
-            Err(Error::with_msg(format!(
-                "type id mismatch  expect {:04x}  found {:04x}  {:?}",
-                tyid,
-                frame.tyid(),
-                frame
-            )))
+            Err(Error::TyIdMismatch(tyid, frame.tyid()))
         } else {
             match decode_from_slice(frame.buf()) {
                 Ok(item) => Ok(item),