lib: add type for input/output variant differentiation

Introduce an enum which stores 2 different possible variants of
inputs or outputs to be passed to encoder and decoder/accessor
instances, depending whether to read/write a fully self contained
pxar archive or whether to split off the payload stream into a
separate input/output.

Co-authored-by: Dominik Csapak <d.csapak@proxmox.com>
Signed-off-by: Christian Ebner <c.ebner@proxmox.com>

src/lib.rs

@@ -494,3 +494,65 @@ impl Entry {
         }
     }
 }
+
+#[derive(Clone)]
+/// Possible variants of the encoder output and decoder as well as accessor inputs
+///
+/// Allow to have a unified or split input/output, depending on whether this is a split
+/// archive or not.
+pub enum PxarVariant<A, P> {
+    /// All of the pxar archive is contained within the given input/output
+    Unified(A),
+    /// Metadata and payload are split into separate inputs/outputs
+    Split(A, P),
+}
+
+impl<A, P> PxarVariant<A, P> {
+    pub fn archive(&self) -> &A {
+        match self {
+            PxarVariant::Unified(a) => a,
+            PxarVariant::Split(a, _) => a,
+        }
+    }
+
+    pub fn archive_mut(&mut self) -> &mut A {
+        match self {
+            PxarVariant::Unified(a) => a,
+            PxarVariant::Split(a, _) => a,
+        }
+    }
+
+    pub fn payload(&self) -> Option<&P> {
+        match self {
+            PxarVariant::Unified(_) => None,
+            PxarVariant::Split(_, p) => Some(p),
+        }
+    }
+
+    pub fn payload_mut(&mut self) -> Option<&mut P> {
+        match self {
+            PxarVariant::Unified(_) => None,
+            PxarVariant::Split(_, p) => Some(p),
+        }
+    }
+
+    pub fn wrap_multi<OUT1, OUT2, F1: Fn(A) -> OUT1, F2: Fn(P) -> OUT2>(
+        self,
+        f1: F1,
+        f2: F2,
+    ) -> PxarVariant<OUT1, OUT2> {
+        match self {
+            PxarVariant::Unified(a) => PxarVariant::Unified(f1(a)),
+            PxarVariant::Split(a, p) => PxarVariant::Split(f1(a), f2(p)),
+        }
+    }
+}
+
+impl<IN> PxarVariant<IN, IN> {
+    pub fn wrap<OUT, F: Fn(IN) -> OUT>(self, f: F) -> PxarVariant<OUT, OUT> {
+        match self {
+            PxarVariant::Unified(a) => PxarVariant::Unified(f(a)),
+            PxarVariant::Split(a, p) => PxarVariant::Split(f(a), f(p)),
+        }
+    }
+}