Fold sizes into toc command

This seems nice because they do *almost* the same thing? And it will be
more obvious if these two chunks of code get out of sync...

Author: sampsyo

flatgfa/src/cli/cmds.rs

@@ -14,20 +14,40 @@ use std::io::Write;
 /// print the FlatGFA table of contents
 #[derive(FromArgs, PartialEq, Debug)]
 #[argh(subcommand, name = "toc")]
-pub struct Toc {}
-
-pub fn toc(gfa: &flatgfa::FlatGFA) {
-    eprintln!("header: {}", gfa.header.len());
-    eprintln!("segs: {}", gfa.segs.len());
-    eprintln!("paths: {}", gfa.paths.len());
-    eprintln!("links: {}", gfa.links.len());
-    eprintln!("steps: {}", gfa.steps.len());
-    eprintln!("seq_data: {}", gfa.seq_data.len());
-    eprintln!("overlaps: {}", gfa.overlaps.len());
-    eprintln!("alignment: {}", gfa.alignment.len());
-    eprintln!("name_data: {}", gfa.name_data.len());
-    eprintln!("optional_data: {}", gfa.optional_data.len());
-    eprintln!("line_order: {}", gfa.line_order.len());
+pub struct Toc {
+    /// show sizes in bytes instead of element counts
+    #[argh(switch, short = 'b')]
+    bytes: bool,
+}
+
+pub fn toc(gfa: &flatgfa::FlatGFA, args: Toc) {
+    if args.bytes {
+        // Show sizes in bytes.
+        println!("header: {}", gfa.header.size());
+        println!("segs: {}", gfa.segs.size());
+        println!("paths: {}", gfa.paths.size());
+        println!("links: {}", gfa.links.size());
+        println!("steps: {}", gfa.steps.size());
+        println!("seq_data: {}", gfa.seq_data.size());
+        println!("overlaps: {}", gfa.overlaps.size());
+        println!("alignment: {}", gfa.alignment.size());
+        println!("name_data: {}", gfa.name_data.size());
+        println!("optional_data: {}", gfa.optional_data.size());
+        println!("line_order: {}", gfa.line_order.size());
+    } else {
+        // Show element counts (which is what we record physically in the TOC).
+        println!("header: {}", gfa.header.len());
+        println!("segs: {}", gfa.segs.len());
+        println!("paths: {}", gfa.paths.len());
+        println!("links: {}", gfa.links.len());
+        println!("steps: {}", gfa.steps.len());
+        println!("seq_data: {}", gfa.seq_data.len());
+        println!("overlaps: {}", gfa.overlaps.len());
+        println!("alignment: {}", gfa.alignment.len());
+        println!("name_data: {}", gfa.name_data.len());
+        println!("optional_data: {}", gfa.optional_data.len());
+        println!("line_order: {}", gfa.line_order.len());
+    }
 }
 
 /// list the paths
@@ -379,22 +399,3 @@ pub fn seq_export(args: SeqExport) {
     let view = store.as_ref();
     packedseq::export(view, &args.output);
 }
-
-/// get the sizes of GFA components, in bytes
-#[derive(FromArgs, PartialEq, Debug)]
-#[argh(subcommand, name = "size")]
-pub struct SizeStats {}
-
-pub fn size_stats(gfa: &flatgfa::FlatGFA) {
-    println!("header: {}", gfa.header.size());
-    println!("segs: {}", gfa.segs.size());
-    println!("paths: {}", gfa.paths.size());
-    println!("links: {}", gfa.links.size());
-    println!("steps: {}", gfa.steps.size());
-    println!("seq_data: {}", gfa.seq_data.size());
-    println!("overlaps: {}", gfa.overlaps.size());
-    println!("alignment: {}", gfa.alignment.size());
-    println!("name_data: {}", gfa.name_data.size());
-    println!("optional_data: {}", gfa.optional_data.size());
-    println!("line_order: {}", gfa.line_order.size());
-}

flatgfa/src/cli/main.rs

@@ -46,7 +46,6 @@ enum Command {
     BedIntersect(cmds::BEDIntersect),
     SeqExport(cmds::SeqExport),
     SeqImport(cmds::SeqImport),
-    SizeStats(cmds::SizeStats),
 }
 
 fn main() -> Result<(), &'static str> {
@@ -112,11 +111,8 @@ fn main() -> Result<(), &'static str> {
     };
 
     match args.command {
-        Some(Command::SizeStats(_)) => {
-            cmds::size_stats(&gfa);
-        }
-        Some(Command::Toc(_)) => {
-            cmds::toc(&gfa);
+        Some(Command::Toc(sub_args)) => {
+            cmds::toc(&gfa, sub_args);
         }
         Some(Command::Paths(_)) => {
             cmds::paths(&gfa);