Continue to work on

Author: InAnYan

module/core/format_tools/src/format/output_format.rs

@@ -32,6 +32,8 @@
 mod private
 {
 
+  use std::borrow::Cow;
+
   use crate::*;
   use print::
   {
@@ -78,6 +80,57 @@ mod private
     }
   }
 
+  /*
+  pub fn table_data_write< 'buf, 'data, 'context >
+  (
+    table : &Vec< Vec< Cow< 'data, str > > >,
+    has_header : bool,
+    filter_col : &'context ( dyn FilterCol + 'context ),
+    filter_row : &'context ( dyn FilterRow + 'context ),
+    output_format : impl TableOutputFormat,
+    c : &mut Context< 'buf >,
+  ) -> fmt::Result
+  {
+    struct TableWrapper< 'data >
+    {
+      has_header : bool,
+      data : &'data Vec< Vec< Cow< 'data, str > > >,
+    }
+
+    struct CellsWrapper< 'data >
+    {
+      header : Option< &'data Vec< Cow< 'data, str
+      data : &'data Vec< Cow< 'data, str > >,
+    }
+
+    impl Cells< str > for CellsWrapper
+    {
+      fn cells< 'a, 'b >( &'a self ) -> impl IteratorTrait< Item = ( &'b CellKey, Option< Cow< 'b, str > > ) >
+      where
+        'a : 'b,
+        CellKey : 'b,
+      {
+        self.data.iter().map( | c |  )
+      }
+    }
+
+    impl TableRows for TableWrapper
+    {
+      fn rows( &self ) -> impl IteratorTrait< Item = &Self::Row >
+      {
+        self.data.iter().skip( if self.has_header { 1 } else { 0 } )
+      }
+    }
+
+    let wrapped_table = TableWrapper { has_header, data : table };
+
+    InputExtract::extract( &wrapped_table, filter_col, filter_row, | x |
+    {
+      output_format.extract_write( x, c )
+    })
+  }
+  */
+
 }
 
 mod table;

module/core/format_tools/src/format/print.rs

@@ -364,6 +364,7 @@ mod private
         ""
       }
     }
+
     /// Extract input data from and collect it in a format consumable by output formatter.
     pub fn extract< 't, 'context, Table, RowKey, Row, CellKey>
     (
@@ -379,9 +380,27 @@ mod private
       Table : TableRows< RowKey = RowKey, Row = Row, CellKey = CellKey >,
       Table : TableHeader< CellKey = CellKey >,
       RowKey : table::RowKey,
-      Row : Cells< CellKey> + 'data,
+      Row : Cells< CellKey > + 'data,
       CellKey : table::CellKey + ?Sized + 'data,
       // CellRepr : table::CellRepr,
+    {
+      Self::extract_from_raw_table
+      (
+        filter_col,
+        filter_row,
+        callback,
+      )
+    }
+
+    pub fn extract_from_raw_table< 'context >
+    (
+      column_names : Vec< Cow< 'data, str > >,
+      has_header : bool,
+      rows : Vec< Vec< Cow< 'data, str > > >,
+      filter_col : &'context ( dyn FilterCol + 'context ),
+      filter_row : &'context ( dyn FilterRow + 'context ),
+      callback : impl for< 'a2 > FnOnce( &'a2 InputExtract< 'a2 > ) -> fmt::Result,
+    ) -> fmt::Result
     {
       use md_math::MdOffset;
 
@@ -391,19 +410,17 @@ mod private
       let mut mchars = [ 0 ; 2 ];
 
       //                                 key        width, index
-      let mut key_to_ikey : HashMap< &'t CellKey, usize > = HashMap::new();
+      let mut key_to_ikey : HashMap< Cow< 'data, str >, usize > = HashMap::new();
 
       let mut col_descriptors : Vec< ColDescriptor< '_ > > = Vec::with_capacity( mcells[ 0 ] );
       let mut row_descriptors : Vec< RowDescriptor > = Vec::with_capacity( mcells[ 1 ] );
-      let mut has_header = false;
 
-      let mut data : Vec< Vec< ( Cow< 't, str >, [ usize ; 2 ] ) > > = Vec::new();
-      let rows = table.rows();
+      let mut data : Vec< Vec< ( Cow< 'data, str >, [ usize ; 2 ] ) > > = Vec::new();
       let mut irow : usize = 0;
       let filter_col_need_args = filter_col.need_args();
       // let filter_row_need_args = filter_row.need_args();
 
-      let mut row_add = | row_iter : &'_ mut dyn _IteratorTrait< Item = ( &'t CellKey, Cow< 't, str > ) >, typ : LineType |
+      let mut row_add = | row_data : Vec< Cow< 'data, str > >, typ : LineType |
       {
 
         irow = row_descriptors.len();
@@ -413,18 +430,21 @@ mod private
         let mut ncol = 0;
         let mut ncol_vis = 0;
 
-        let fields : Vec< ( Cow< 't, str >, [ usize ; 2 ] ) > = row_iter
+        let fields : Vec< ( Cow< 'data, str >, [ usize ; 2 ] ) > = row_data
+        .into_iter()
+        .enumerate()
         .filter_map
         (
-          | ( key, val ) |
+          | ( ikey, val ) |
           {
+            let key = &column_names[ ikey ];
             let l = col_descriptors.len();
 
             ncol += 1;
 
             if filter_col_need_args
             {
-              if !filter_col.filter_col( key.borrow() )
+              if !filter_col.filter_col( key.as_ref() )
               {
                 return None;
               }
@@ -442,7 +462,7 @@ mod private
             let sz = string::size( &val );
 
             key_to_ikey
-            .entry( key )
+            .entry( key.clone() )
             .and_modify( | icol |
             {
               let col = &mut col_descriptors[ *icol ];
@@ -481,18 +501,9 @@ mod private
 
       // process header first
 
-      if let Some( header ) = table.header()
+      if has_header
       {
-        rows.len().checked_add( 1 ).expect( "Table has too many rows" );
-        // assert!( header.len() <= usize::MAX, "Header of a table has too many cells" );
-        has_header = true;
-
-        let mut row2 =  header.map( | ( key, title ) |
-        {
-          ( key, Cow::Borrowed( title ) )
-        });
-
-        row_add( &mut row2, LineType::Header );
+        row_add( column_names.clone(), LineType::Header );
       }
 
       // Collect rows
@@ -501,30 +512,7 @@ mod private
       {
         // assert!( row.cells().len() <= usize::MAX, "Row of a table has too many cells" );
 
-        let mut row2 = row
-        .cells()
-        .map
-        (
-          | ( key, val ) |
-          {
-
-            let val = match val
-            {
-              Some( val ) =>
-              {
-                val
-              }
-              None =>
-              {
-                Cow::Borrowed( "" )
-              }
-            };
-
-            return ( key, val );
-          }
-        );
-
-        row_add( &mut row2, LineType::Regular );
+        row_add( row, LineType::Regular );
       }
 
       // calculate size in chars

module/core/format_tools/tests/tests.rs

@@ -1,6 +1,6 @@
 //! Primary tests.
 
-#![ feature( trace_macros ) ]
+// #![ feature( trace_macros ) ]
 #![ allow( unused_imports ) ]
 
 use format_tools as the_module;