Increased performance ~20% of write_to_tsv() by removing clone().

  - This introduced two new non-borrowing structs,
    `GenomicRangeRecordEmptyBorrowed` and `GenomicRangeRecordBorrowed`,
    which pass the sequence name by reference, avoiding a
    `clone()` which can be quite costly when serialzing
    many genomic ranges.

 - `seqname()` in `GenomicRangeRecord` also know returns a reference,
   which seems to also improve performance in some situations.

 - Slight change to `GRanges::push_range()` methods, for optimziation
   (simplified code a bit).

src/granges.rs

@@ -241,10 +241,11 @@ where
         config: &TsvConfig,
     ) -> Result<(), GRangesError> {
         let mut writer = build_tsv_writer_with_config(output, config)?;
+        let seqnames = &self.ranges.sorted_keys;
 
         for range in self.iter_ranges() {
             let record = range.to_record(
-                &self.seqnames(),
+                &seqnames,
                 self.data.as_ref().ok_or(GRangesError::NoDataContainer)?,
             );
             writer.serialize(record)?;
@@ -268,10 +269,11 @@ impl<'a, R: IterableRangeContainer> GenomicRangesTsvSerialize<'a, R> for GRanges
         output: Option<impl Into<PathBuf>>,
         config: &TsvConfig,
     ) -> Result<(), GRangesError> {
+        let seqnames = &self.0.ranges.sorted_keys;
         let mut writer = build_tsv_writer_with_config(output, config)?;
 
         for range in self.iter_ranges() {
-            let record = range.to_record_empty::<()>(&self.seqnames());
+            let record = range.to_record_empty::<()>(&seqnames);
             writer.serialize(record)?;
         }
 
@@ -738,11 +740,8 @@ impl<U> GRanges<VecRangesIndexed, Vec<U>> {
             self.data = Some(Vec::new());
         }
         let data_ref = self.data.as_mut().ok_or(GRangesError::NoDataContainer)?;
-        // push data to the vec data container, getting the index
-        let index: usize = {
-            data_ref.push(data);
-            data_ref.len() - 1 // new data index
-        };
+        let index = data_ref.len();
+        data_ref.push(data);
         // push an indexed range
         let range = RangeIndexed::new(start, end, index);
         let range_container = self
@@ -797,11 +796,8 @@ impl<'a, DL, DR> GRanges<VecRangesIndexed, JoinData<'a, DL, DR>> {
             panic!("Internal error: JoinData not initialized.");
         }
         let data_ref = self.data.as_mut().ok_or(GRangesError::NoDataContainer)?;
-        // push data to the vec data container, getting the index
-        let index: usize = {
-            data_ref.push(data);
-            data_ref.len() - 1 // new data index
-        };
+        let index = data_ref.len();
+        data_ref.push(data);
         // push an indexed range
         let range = RangeIndexed::new(start, end, index);
         let range_container = self
@@ -1872,7 +1868,7 @@ mod tests {
         let seqnames = sl.keys().map(|x| x.to_string()).collect::<Vec<_>>();
         let actual_ranges: Vec<(String, Position, Position)> = gr
             .iter_ranges()
-            .map(|r| (r.seqname(&seqnames), r.start(), r.end()))
+            .map(|r| (r.seqname(&seqnames).to_string(), r.start(), r.end()))
             .collect();
         assert_eq!(actual_ranges, expected_ranges_chop);
 
@@ -1904,7 +1900,7 @@ mod tests {
 
         let actual_ranges: Vec<(String, Position, Position)> = gr
             .iter_ranges()
-            .map(|r| (r.seqname(&seqnames), r.start(), r.end()))
+            .map(|r| (r.seqname(&seqnames).to_string(), r.start(), r.end()))
             .collect();
 
         assert_eq!(actual_ranges, expected_ranges_no_chop);

src/ranges/mod.rs

@@ -163,10 +163,30 @@ impl AdjustableGenericRange for RangeIndexed {
     }
 }
 
+/// Represents a genomic range entry with some borrowed data.
+/// This is used primarily as a temporary store for deserializing
+/// a genomic range.
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub struct GenomicRangeRecordEmptyBorrowed<'a> {
+    pub seqname: &'a str,
+    pub start: Position,
+    pub end: Position,
+}
+
+/// Represents a genomic range entry with some borrowed data.
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub struct GenomicRangeRecordBorrowed<'a, U> {
+    pub seqname: &'a str,
+    pub start: Position,
+    pub end: Position,
+    pub data: U,
+}
+
 /// Represents a genomic range entry with some data.
 ///
 /// This is used as a type for holding a range with associated data directly
-/// from a parser.
+/// from a parser. Thus it owns the memory it uses for the seqname and the
+/// data.
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct GenomicRangeRecord<U> {
     pub seqname: String,
@@ -364,29 +384,30 @@ impl GenomicRangeIndexedRecord {
     }
     /// Using the *corresponding ordered* sequence names the `seqname_index` indices
     /// correspond to, get the sequence name.
-    pub fn seqname(&self, seqnames: &[String]) -> String {
-        seqnames[self.seqname_index].clone()
+    pub fn seqname<'a>(&'a self, seqnames: &'a [String]) -> &String {
+        &seqnames[self.seqname_index]
     }
     pub fn to_record<'a, T>(
         self,
-        seqnames: &[String],
+        seqnames: &'a[String],
         data: &'a T,
-    ) -> GenomicRangeRecord<<T as IndexedDataContainer>::Item<'a>>
+    ) -> GenomicRangeRecordBorrowed<'a, <T as IndexedDataContainer>::Item<'a>>
     where
         T: IndexedDataContainer,
     {
         let data = data.get_value(self.index().unwrap());
 
-        GenomicRangeRecord {
-            seqname: seqnames[self.seqname_index].clone(),
+        GenomicRangeRecordBorrowed {
+            seqname: &seqnames[self.seqname_index],
             start: self.start,
             end: self.end,
             data,
         }
     }
-    pub fn to_record_empty<T>(self, seqnames: &[String]) -> GenomicRangeRecordEmpty {
-        GenomicRangeRecordEmpty {
-            seqname: seqnames[self.seqname_index].clone(),
+    pub fn to_record_empty<'a, T>(self, seqnames: &'a[String]) -> 
+        GenomicRangeRecordEmptyBorrowed<'a> {
+        GenomicRangeRecordEmptyBorrowed {
+            seqname: &seqnames[self.seqname_index],
             start: self.start,
             end: self.end,
         }