feat: impl ReaderBuilder

sdk/src/assertions/bmff_hash.rs

@@ -816,11 +816,10 @@ impl BmffHash {
         Ok(())
     }
 
-    #[cfg(feature = "file_io")]
     pub fn verify_stream_segments(
         &self,
         init_stream: &mut dyn CAIRead,
-        fragment_paths: &Vec<std::path::PathBuf>,
+        fragment_paths: &mut [Box<dyn CAIRead>],
         alg: Option<&str>,
     ) -> crate::Result<()> {
         self.verify_self()?;
@@ -849,11 +848,9 @@ impl BmffHash {
                 return Err(Error::HashMismatch("No fragment specified".to_string()));
             }
 
-            for fp in fragment_paths {
-                let mut fragment_stream = std::fs::File::open(fp)?;
-
+            for mut fragment_stream in fragment_paths {
                 // get merkle boxes from segment
-                let c2pa_boxes = read_bmff_c2pa_boxes(&mut fragment_stream)?;
+                let c2pa_boxes = read_bmff_c2pa_boxes(fragment_stream)?;
                 let bmff_merkle = c2pa_boxes.bmff_merkle;
 
                 if bmff_merkle.is_empty() {

sdk/src/claim.rs

@@ -113,8 +113,7 @@ pub enum ClaimAssetData<'a> {
     Bytes(&'a [u8], &'a str),
     Stream(&'a mut dyn CAIRead, &'a str),
     StreamFragment(&'a mut dyn CAIRead, &'a mut dyn CAIRead, &'a str),
-    #[cfg(feature = "file_io")]
-    StreamFragments(&'a mut dyn CAIRead, &'a Vec<std::path::PathBuf>, &'a str),
+    StreamFragments(&'a mut dyn CAIRead, &'a mut [Box<dyn CAIRead>], &'a str),
 }
 
 #[derive(PartialEq, Debug, Eq, Clone, Hash)]
@@ -2687,7 +2686,6 @@ impl Claim {
                                 *fragment_data,
                                 Some(claim.alg()),
                             ),
-                        #[cfg(feature = "file_io")]
                         ClaimAssetData::StreamFragments(initseg_data, fragment_paths, _) => dh
                             .verify_stream_segments(
                                 *initseg_data,

sdk/src/error.rs

@@ -364,7 +364,7 @@ pub enum Error {
 }
 
 /// A specialized `Result` type for C2PA toolkit operations.
-pub type Result<T> = std::result::Result<T, Error>;
+pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 impl From<CoseError> for Error {
     fn from(err: CoseError) -> Self {

sdk/src/reader.rs

@@ -32,14 +32,15 @@ use serde_with::skip_serializing_none;
 #[cfg(feature = "file_io")]
 use crate::utils::io_utils::uri_to_path;
 use crate::{
+    asset_io::CAIRead,
     crypto::base64,
     dynamic_assertion::PartialClaim,
     error::{Error, Result},
     jumbf::labels::{manifest_label_from_uri, to_absolute_uri, to_relative_uri},
     jumbf_io,
     manifest::StoreOptions,
     manifest_store_report::ManifestStoreReport,
-    settings::get_settings_value,
+    settings::{get_settings_value, Settings},
     status_tracker::StatusTracker,
     store::Store,
     validation_results::{ValidationResults, ValidationState},
@@ -72,6 +73,77 @@ pub trait AsyncPostValidator {
     ) -> Result<Option<Value>>;
 }
 
+pub struct ReaderBuilder {
+    settings: Settings,
+    external_manifest: Option<Box<dyn CAIRead>>,
+    fragments: Option<Vec<Box<dyn CAIRead>>>,
+}
+
+impl ReaderBuilder {
+    pub fn new() -> Self {
+        Self {
+            settings: Settings::default(),
+            external_manifest: None,
+            fragments: None,
+        }
+    }
+
+    pub fn with_settings(settings: Settings) -> Self {
+        Self {
+            settings,
+            external_manifest: None,
+            fragments: None,
+        }
+    }
+
+    pub fn external_manifest(
+        mut self,
+        external_manifest: impl Read + Seek + Send + 'static,
+    ) -> Self {
+        self.external_manifest = Some(Box::new(external_manifest));
+        self
+    }
+
+    pub fn add_fragment(mut self, fragment: impl Read + Seek + Send + 'static) -> Self {
+        let fragments = self.fragments.get_or_insert_default();
+        fragments.push(Box::new(fragment));
+        self
+    }
+
+    // pub fn http_resolver(self, resolver: impl SyncHttpResolver) -> Self {
+    //     todo!()
+    // }
+
+    // TODO: impl the async cases
+    // TODO: pass the settings down the stack (waiting on #1444)
+    #[async_generic]
+    pub fn build(self, format: &str, stream: impl Read + Seek + Send) -> Result<Reader> {
+        match self.fragments {
+            Some(mut fragments) => {
+                // TODO: can we pass in an external manifest here?
+                match self.external_manifest {
+                    Some(external_manifest) => {
+                        // TODO: we can add a from_manifest_data_and_fragments function
+                        todo!()
+                    }
+                    None => Reader::from_fragments(format, stream, &mut fragments),
+                }
+            }
+            None => match self.external_manifest {
+                Some(mut external_manifest) => {
+                    // TODO: internally we actually convert c2pa_data to a stream again, we should modify the function
+                    //       signatures to stream by default
+                    let mut c2pa_data = Vec::new();
+                    external_manifest.read_to_end(&mut c2pa_data)?;
+
+                    Reader::from_manifest_data_and_stream(&c2pa_data, format, stream)
+                }
+                None => Reader::from_stream(format, stream),
+            },
+        }
+    }
+}
+
 /// Use a Reader to read and validate a manifest store.
 #[skip_serializing_none]
 #[derive(Serialize, Deserialize)]
@@ -297,6 +369,29 @@ impl Reader {
         Self::from_store(store, &validation_log)
     }
 
+    // TODO: doc
+    pub fn from_fragments(
+        format: &str,
+        mut init_segment: impl Read + Seek + Send,
+        // TODO: make this take impl Read + Seek + Send
+        fragments: &mut [Box<dyn CAIRead>],
+    ) -> Result<Self> {
+        let verify = get_settings_value::<bool>("verify.verify_after_reading")?; // defaults to true
+
+        let mut validation_log = StatusTracker::default();
+
+        match Store::load_fragments_from_stream(
+            &format,
+            &mut init_segment,
+            fragments,
+            verify,
+            &mut validation_log,
+        ) {
+            Ok(store) => Self::from_store(store, &validation_log),
+            Err(e) => Err(e),
+        }
+    }
+
     #[cfg(feature = "file_io")]
     /// Loads a [`Reader`]` from an initial segment and fragments.  This
     /// would be used to load and validate fragmented MP4 files that span
@@ -314,10 +409,15 @@ impl Reader {
 
         let mut init_segment = std::fs::File::open(path.as_ref())?;
 
-        match Store::load_from_file_and_fragments(
+        let mut fragments: Vec<Box<dyn CAIRead>> = fragments
+            .iter()
+            .map(|path| File::open(path).map(|file| Box::new(file) as Box<dyn CAIRead>))
+            .collect::<Result<_, std::io::Error>>()?;
+
+        match Store::load_fragments_from_stream(
             &asset_type,
             &mut init_segment,
-            fragments,
+            &mut fragments,
             verify,
             &mut validation_log,
         ) {

sdk/src/store.rs

@@ -12,7 +12,7 @@
 // each license.
 
 #[cfg(feature = "file_io")]
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::{
     collections::{HashMap, HashSet},
     io::{Cursor, Read, Seek},
@@ -1965,8 +1965,7 @@ impl Store {
                 let format = typ.to_owned();
                 object_locations_from_stream(&format, reader)
             }
-            #[cfg(feature = "file_io")]
-            ClaimAssetData::StreamFragments(reader, _path_bufs, typ) => {
+            ClaimAssetData::StreamFragments(reader, _fragments, typ) => {
                 let format = typ.to_owned();
                 object_locations_from_stream(&format, reader)
             }
@@ -3716,11 +3715,10 @@ impl Store {
     /// fragments: list of paths to the fragments to verify
     /// verify: if true will run verification checks when loading, all fragments must verify for Ok status
     /// validation_log: If present all found errors are logged and returned, otherwise first error causes exit and is returned
-    #[cfg(feature = "file_io")]
-    pub fn load_from_file_and_fragments(
+    pub fn load_fragments_from_stream(
         asset_type: &str,
         init_segment: &mut dyn CAIRead,
-        fragments: &Vec<PathBuf>,
+        fragments: &mut [Box<dyn CAIRead>],
         verify: bool,
         validation_log: &mut StatusTracker,
     ) -> Result<Store> {
@@ -7887,15 +7885,18 @@ pub mod tests {
                     // test verifying all at once
                     let mut output_fragments = Vec::new();
                     for entry in &fragments {
-                        output_fragments.push(new_output_path.join(entry.file_name().unwrap()));
+                        let file =
+                            std::fs::File::open(new_output_path.join(entry.file_name().unwrap()))
+                                .unwrap();
+                        output_fragments.push(Box::new(file) as Box<dyn CAIRead>);
                     }
 
                     //let mut reader = Cursor::new(init_stream);
                     let mut validation_log = StatusTracker::default();
-                    let _manifest = Store::load_from_file_and_fragments(
+                    let _manifest = Store::load_fragments_from_stream(
                         "mp4",
                         &mut init_stream,
-                        &output_fragments,
+                        &mut output_fragments,
                         false,
                         &mut validation_log,
                     )