Start implementing manifest, picklist and selection

include/sourmash.h

@@ -16,6 +16,12 @@ enum HashFunctions {
 };
 typedef uint32_t HashFunctions;
 
+enum PickStyle {
+  PICK_STYLE_INCLUDE = 1,
+  PICK_STYLE_EXCLUDE = 2,
+};
+typedef uint32_t PickStyle;
+
 enum SourmashErrorCode {
   SOURMASH_ERROR_CODE_NO_ERROR = 0,
   SOURMASH_ERROR_CODE_PANIC = 1,
@@ -42,6 +48,7 @@ enum SourmashErrorCode {
   SOURMASH_ERROR_CODE_PARSE_INT = 100003,
   SOURMASH_ERROR_CODE_SERDE_ERROR = 100004,
   SOURMASH_ERROR_CODE_NIFFLER_ERROR = 100005,
+  SOURMASH_ERROR_CODE_CSV_ERROR = 100006,
 };
 typedef uint32_t SourmashErrorCode;
 
@@ -51,14 +58,24 @@ typedef struct SourmashHyperLogLog SourmashHyperLogLog;
 
 typedef struct SourmashKmerMinHash SourmashKmerMinHash;
 
+typedef struct SourmashManifest SourmashManifest;
+
+typedef struct SourmashManifestRowIter SourmashManifestRowIter;
+
 typedef struct SourmashNodegraph SourmashNodegraph;
 
+typedef struct SourmashPicklist SourmashPicklist;
+
 typedef struct SourmashRevIndex SourmashRevIndex;
 
 typedef struct SourmashSearchResult SourmashSearchResult;
 
+typedef struct SourmashSelection SourmashSelection;
+
 typedef struct SourmashSignature SourmashSignature;
 
+typedef struct SourmashSignatureIter SourmashSignatureIter;
+
 typedef struct SourmashZipStorage SourmashZipStorage;
 
 /**
@@ -79,6 +96,15 @@ typedef struct {
   bool owned;
 } SourmashStr;
 
+typedef struct {
+  uint32_t ksize;
+  uint8_t with_abundance;
+  SourmashStr md5;
+  SourmashStr internal_location;
+  SourmashStr name;
+  SourmashStr moltype;
+} SourmashManifestRow;
+
 bool computeparams_dayhoff(const SourmashComputeParameters *ptr);
 
 bool computeparams_dna(const SourmashComputeParameters *ptr);
@@ -265,6 +291,10 @@ void kmerminhash_slice_free(uint64_t *ptr, uintptr_t insize);
 
 bool kmerminhash_track_abundance(const SourmashKmerMinHash *ptr);
 
+SourmashManifestRowIter *manifest_rows(const SourmashManifest *ptr);
+
+const SourmashManifestRow *manifest_rows_iter_next(SourmashManifestRowIter *ptr);
+
 void nodegraph_buffer_free(uint8_t *ptr, uintptr_t insize);
 
 bool nodegraph_count(SourmashNodegraph *ptr, uint64_t h);
@@ -309,6 +339,18 @@ SourmashNodegraph *nodegraph_with_tables(uintptr_t ksize,
                                          uintptr_t starting_size,
                                          uintptr_t n_tables);
 
+void picklist_free(SourmashPicklist *ptr);
+
+SourmashPicklist *picklist_new(void);
+
+void picklist_set_coltype(SourmashPicklist *ptr, const char *coltype_ptr, uintptr_t insize);
+
+void picklist_set_column_name(SourmashPicklist *ptr, const char *prop_ptr, uintptr_t insize);
+
+void picklist_set_pickfile(SourmashPicklist *ptr, const char *prop_ptr, uintptr_t insize);
+
+void picklist_set_pickstyle(SourmashPicklist *ptr, PickStyle pickstyle);
+
 void revindex_free(SourmashRevIndex *ptr);
 
 const SourmashSearchResult *const *revindex_gather(const SourmashRevIndex *ptr,
@@ -354,6 +396,36 @@ double searchresult_score(const SourmashSearchResult *ptr);
 
 SourmashSignature *searchresult_signature(const SourmashSearchResult *ptr);
 
+bool selection_abund(const SourmashSelection *ptr);
+
+bool selection_containment(const SourmashSelection *ptr);
+
+uint32_t selection_ksize(const SourmashSelection *ptr);
+
+HashFunctions selection_moltype(const SourmashSelection *ptr);
+
+SourmashSelection *selection_new(void);
+
+uint32_t selection_num(const SourmashSelection *ptr);
+
+const SourmashPicklist *selection_picklist(const SourmashSelection *ptr);
+
+uint32_t selection_scaled(const SourmashSelection *ptr);
+
+void selection_set_abund(SourmashSelection *ptr, bool new_abund);
+
+void selection_set_containment(SourmashSelection *ptr, bool new_containment);
+
+void selection_set_ksize(SourmashSelection *ptr, uint32_t new_ksize);
+
+void selection_set_moltype(SourmashSelection *ptr, HashFunctions new_moltype);
+
+void selection_set_num(SourmashSelection *ptr, uint32_t new_num);
+
+void selection_set_picklist(SourmashSelection *ptr, SourmashPicklist *new_picklist);
+
+void selection_set_scaled(SourmashSelection *ptr, uint32_t new_scaled);
+
 void signature_add_protein(SourmashSignature *ptr, const char *sequence);
 
 void signature_add_sequence(SourmashSignature *ptr, const char *sequence, bool force);
@@ -388,6 +460,8 @@ void signature_set_mh(SourmashSignature *ptr, const SourmashKmerMinHash *other);
 
 void signature_set_name(SourmashSignature *ptr, const char *name);
 
+const SourmashSignature *signatures_iter_next(SourmashSignatureIter *ptr);
+
 SourmashSignature **signatures_load_buffer(const char *ptr,
                                            uintptr_t insize,
                                            bool _ignore_md5sum,

src/core/Cargo.toml

@@ -29,6 +29,7 @@ bytecount = "0.6.0"
 byteorder = "1.4.3"
 cfg-if = "1.0"
 counter = "0.5.7"
+csv = "1.1.6"
 finch = { version = "0.6.0", optional = true }
 fixedbitset = "0.4.0"
 getrandom = { version = "0.2", features = ["js"] }

src/core/src/errors.rs

@@ -63,6 +63,9 @@ pub enum SourmashError {
     #[error(transparent)]
     IOError(#[from] std::io::Error),
 
+    #[error(transparent)]
+    CsvError(#[from] csv::Error),
+
     #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
     #[error(transparent)]
     Panic(#[from] crate::ffi::utils::Panic),
@@ -108,6 +111,7 @@ pub enum SourmashErrorCode {
     ParseInt = 100_003,
     SerdeError = 100_004,
     NifflerError = 100_005,
+    CsvError = 100_006,
 }
 
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
@@ -137,6 +141,7 @@ impl SourmashErrorCode {
             SourmashError::IOError { .. } => SourmashErrorCode::Io,
             SourmashError::NifflerError { .. } => SourmashErrorCode::NifflerError,
             SourmashError::Utf8Error { .. } => SourmashErrorCode::Utf8Error,
+            SourmashError::CsvError { .. } => SourmashErrorCode::CsvError,
         }
     }
 }

src/core/src/ffi/index/mod.rs

@@ -1,7 +1,11 @@
 pub mod revindex;
 
+use crate::encodings::HashFunctions;
+use crate::index::{Selection, SigStore};
+
 use crate::signature::Signature;
 
+use crate::ffi::picklist::SourmashPicklist;
 use crate::ffi::signature::SourmashSignature;
 use crate::ffi::utils::{ForeignObject, SourmashStr};
 
@@ -35,3 +39,164 @@ pub unsafe extern "C" fn searchresult_signature(
     let result = SourmashSearchResult::as_rust(ptr);
     SourmashSignature::from_rust((result.1).clone())
 }
+
+//================================================================
+
+pub struct SourmashSelection;
+
+impl ForeignObject for SourmashSelection {
+    type RustObject = Selection;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_new() -> *mut SourmashSelection {
+    SourmashSelection::from_rust(Selection::default())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_ksize(ptr: *const SourmashSelection) -> u32 {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(ksize) = sel.ksize() {
+        ksize
+    } else {
+        todo!("empty ksize case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_ksize(ptr: *mut SourmashSelection, new_ksize: u32) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    sel.set_ksize(new_ksize);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_num(ptr: *const SourmashSelection) -> u32 {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(num) = sel.num() {
+        num
+    } else {
+        todo!("empty num case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_num(ptr: *mut SourmashSelection, new_num: u32) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    sel.set_num(new_num);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_scaled(ptr: *const SourmashSelection) -> u32 {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(scaled) = sel.scaled() {
+        scaled
+    } else {
+        todo!("empty scaled case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_scaled(ptr: *mut SourmashSelection, new_scaled: u32) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    sel.set_scaled(new_scaled);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_containment(ptr: *const SourmashSelection) -> bool {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(containment) = sel.containment() {
+        containment
+    } else {
+        todo!("empty scaled case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_containment(
+    ptr: *mut SourmashSelection,
+    new_containment: bool,
+) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    sel.set_containment(new_containment);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_abund(ptr: *const SourmashSelection) -> bool {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(abund) = sel.abund() {
+        abund
+    } else {
+        todo!("empty abund case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_abund(ptr: *mut SourmashSelection, new_abund: bool) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    sel.set_abund(new_abund);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_moltype(ptr: *const SourmashSelection) -> HashFunctions {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(hash_function) = sel.moltype() {
+        hash_function
+    } else {
+        todo!("empty hash_function case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_moltype(
+    ptr: *mut SourmashSelection,
+    new_moltype: HashFunctions,
+) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    sel.set_moltype(new_moltype);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_picklist(
+    ptr: *const SourmashSelection,
+) -> *const SourmashPicklist {
+    let sel = SourmashSelection::as_rust(ptr);
+    if let Some(picklist) = sel.picklist() {
+        SourmashPicklist::from_rust(picklist)
+    } else {
+        todo!("empty picklist case not supported yet")
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn selection_set_picklist(
+    ptr: *mut SourmashSelection,
+    new_picklist: *mut SourmashPicklist,
+) {
+    let sel = SourmashSelection::as_rust_mut(ptr);
+    let pick = SourmashPicklist::into_rust(new_picklist);
+    sel.set_picklist(*pick);
+}
+
+//================================================================
+//
+pub struct SignatureIterator {
+    iter: Box<dyn Iterator<Item = SigStore<Signature>>>,
+}
+
+pub struct SourmashSignatureIter;
+
+impl ForeignObject for SourmashSignatureIter {
+    type RustObject = SignatureIterator;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn signatures_iter_next(
+    ptr: *mut SourmashSignatureIter,
+) -> *const SourmashSignature {
+    let iterator = SourmashSignatureIter::as_rust_mut(ptr);
+
+    match iterator.iter.next() {
+        Some(sig) => SourmashSignature::from_rust(sig.into()),
+        None => std::ptr::null(),
+    }
+}