WIP

src/lib.rs

@@ -120,6 +120,7 @@
 mod iterators;
 mod vec;
 mod vec_of;
+mod via;
 
 pub mod identified_vec {
     //! A collection of unique identifiable elements which retains **insertion** order.
@@ -136,5 +137,10 @@ pub mod identified_vec_of {
     pub use crate::vec_of::*;
 }
 
+pub mod identified_vec_via {
+    pub use crate::via::*;
+}
+
 pub use crate::identified_vec::*;
 pub use crate::identified_vec_of::*;
+pub use crate::identified_vec_via::*;

src/vec_of/mod.rs

@@ -2,16 +2,12 @@ mod errors;
 mod identifiable_trait;
 mod identified_vec_of;
 mod is_identified_vec_of;
-mod is_identified_vec_of_via;
-mod newtype_identified_vec_of;
 mod primitives_identifiable;
 
 pub use errors::*;
 pub use identifiable_trait::*;
 pub use identified_vec_of::*;
 pub use is_identified_vec_of::*;
-pub use is_identified_vec_of_via::*;
-pub use newtype_identified_vec_of::*;
 
 #[cfg(feature = "id_prim")]
 pub use primitives_identifiable::*;

src/via/identified_vec_via.rs

@@ -0,0 +1,68 @@
+use crate::{
+    identified_vec_into_iterator::IdentifiedVecIntoIterator, Identifiable, IdentifiedVecOf,
+    IsIdentifiableVecOfVia, ViaMarker,
+};
+
+pub struct IdentifiedVecVia<Element: Identifiable>(IdentifiedVecOf<Element>);
+
+impl<Element: Identifiable> ViaMarker for IdentifiedVecVia<Element> {}
+impl<Element: Identifiable> IsIdentifiableVecOfVia<Element> for IdentifiedVecVia<Element> {
+    fn via_mut(&mut self) -> &mut IdentifiedVecOf<Element> {
+        &mut self.0
+    }
+
+    fn via(&self) -> &IdentifiedVecOf<Element> {
+        &self.0
+    }
+
+    fn from_identified_vec_of(identified_vec_of: IdentifiedVecOf<Element>) -> Self {
+        Self(identified_vec_of)
+    }
+}
+
+impl<Element: Identifiable + std::fmt::Display + std::fmt::Debug> std::fmt::Display
+    for IdentifiedVecVia<Element>
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl<Element: Identifiable> IntoIterator for IdentifiedVecVia<Element> {
+    type Item = Element;
+    type IntoIter = IdentifiedVecIntoIterator<<Element as Identifiable>::ID, Element>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Self::IntoIter::new(self.0)
+    }
+}
+
+#[cfg(any(test, feature = "serde"))]
+impl<Element: Identifiable> serde::Serialize for IdentifiedVecVia<Element>
+where
+    Element: serde::Serialize + Identifiable + std::fmt::Debug + Clone,
+{
+    fn serialize<S>(
+        &self,
+        serializer: S,
+    ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
+    where
+        S: serde::Serializer,
+    {
+        IdentifiedVecOf::serialize(&self.0, serializer)
+    }
+}
+
+#[cfg(any(test, feature = "serde"))]
+impl<'de, Element> serde::Deserialize<'de> for IdentifiedVecVia<Element>
+where
+    Element: serde::Deserialize<'de> + Identifiable + std::fmt::Debug + Clone,
+{
+    #[cfg(not(tarpaulin_include))] // false negative
+    fn deserialize<D: serde::Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<IdentifiedVecVia<Element>, D::Error> {
+        let id_vec_of = IdentifiedVecOf::<Element>::deserialize(deserializer)?;
+        return Ok(Self::from_identified_vec_of(id_vec_of));
+    }
+}

src/vec_of/is_identified_vec_of_via.rs → src/via/is_identified_vec_of_via.rs

@@ -1,10 +1,8 @@
 use crate::{
-    identified_vec_iterator::IdentifiedVecIterator, ConflictResolutionChoice, Error,
-    IsIdentifiedVec, IsIdentifiedVecOf, ItemsCloned,
+    identified_vec_iterator::IdentifiedVecIterator, ConflictResolutionChoice, Error, Identifiable,
+    IdentifiedVecOf, IsIdentifiedVec, IsIdentifiedVecOf, ItemsCloned,
 };
 
-use super::{identifiable_trait::Identifiable, identified_vec_of::IdentifiedVecOf};
-
 /// https://stackoverflow.com/a/66537661/1311272
 pub trait ViaMarker {}
 

src/via/mod.rs

@@ -0,0 +1,7 @@
+mod identified_vec_via;
+mod is_identified_vec_of_via;
+mod newtype_identified_vec_of;
+
+pub use identified_vec_via::*;
+pub use is_identified_vec_of_via::*;
+pub use newtype_identified_vec_of::*;