Update roadmap

The column types were tracked just as a Type. This changes them to be an instance
so they can track additional information (such as the specific units of a physical
units type). Because of this, the column type attribute need to be passed as strings
(see CS0181).

SaneTsv/SaneTsvTest/Program.cs

@@ -1,7 +1,8 @@
 using NathanMcRae;
+using System.Reflection;
 using System.Text;
 
-internal class Program
+internal class Program : SaneTsv
 {
   public class TestRecord : SaneTsv.TsvRecord
   {
@@ -80,6 +81,18 @@ internal class Program
     public string Column3 { get; set; }
   }
 
+  public class BoolTestRecord3 : SaneTsv.CommentedTsvRecord
+  {
+    [SaneTsv.TsvColumn("column1")]
+    public string Column1 { get; set; }
+
+    [SaneTsv.TsvColumn]
+    public string column2 { get; set; }
+
+    [SaneTsv.TsvColumn("columnthree\nyep")]
+    public string Column3 { get; set; }
+  }
+
   public class SerdeTestRecord : SaneTsv.CommentedTsvRecord
   {
     [SaneTsv.TypedTsvColumn("column1")]
@@ -101,6 +114,18 @@ internal class Program
     public double BinFloat { get; set; }
   }
 
+  public class StringTestRecord : SaneTsv.TsvRecord
+  {
+    [SaneTsv.TypedTsvColumn("column1")]
+    public string Column1 { get; set; }
+
+    [SaneTsv.TypedTsvColumn]
+    public string column2 { get; set; }
+
+    [SaneTsv.TypedTsvColumn("columnthree\nyep")]
+    public string Column3 { get; set; }
+  }
+
   private static void Main(string[] args)
   {
     {
@@ -275,7 +300,7 @@ internal class Program
     {
       string testName = "Try to parsed a Typed TSV as a Simple TSV";
 
-      string testString1 = 
+      string testString1 =
         "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
         "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
         "\nFALSE\tnother\tno\\ther";
@@ -292,6 +317,472 @@ internal class Program
       }
     }
 
+    {
+      string testName = "Timing comparison of simple parse methods and comparison of simple serialization methods";
+
+      int N = 1000000;
+      var records = new StringTestRecord[N];
+      var rand = new Random(1);
+
+      for (int i = 0; i < N; i++)
+      {
+        records[i] = new StringTestRecord()
+        {
+          Column1 = rand.Next().ToString(),
+          column2 = rand.Next().ToString(),
+          Column3 = rand.Next().ToString(),
+        };
+      }
+
+      string[][] recordStrings = records.Select(record => new string[] { record.Column1, record.column2, record.Column3 }).ToArray();
+
+      DateTime lastTime = DateTime.Now;
+      byte[] serialized1 = SaneTsv.SerializeSimpleTsv<StringTestRecord>(records);
+
+      TimeSpan speccedSerializationTime = DateTime.Now - lastTime;
+      Console.WriteLine($"Specced serialization time: {speccedSerializationTime}");
+      lastTime = DateTime.Now;
+
+      byte[] serialized2 = SaneTsv.SerializeSimpleTsv(new string[] { "column1", "column2", "columnthree\nyep" }, recordStrings);
+
+      TimeSpan unspeccedSerializationTime = DateTime.Now - lastTime;
+      Console.WriteLine($"Unspecced serialization time: {unspeccedSerializationTime}");
+      lastTime = DateTime.Now;
+
+      Tsv<StringTestRecord> parsed = SaneTsv.ParseSimpleTsv<StringTestRecord>(serialized1);
+
+      TimeSpan speccedParseTime = DateTime.Now - lastTime;
+      Console.WriteLine($"Specced parse time: {speccedParseTime}");
+      lastTime = DateTime.Now;
+
+      (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(serialized2);
+
+      TimeSpan unspeccedParseTime = DateTime.Now - lastTime;
+      Console.WriteLine($"Unspecced parse time: {unspeccedParseTime}");
+    }
+
+    {
+      string testName = "With and without file comment";
+
+      string testString1 = "#This is a file comment\n" +
+        "#One more file comment line\n" +
+        "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\n#This is a comment" +
+        "\n#Another comment line" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther";
+
+      string testString2 = "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\n#This is a comment" +
+        "\n#Another comment line" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther";
+
+      CommentedTsv<BoolTestRecord2> parsed = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+      CommentedTsv<BoolTestRecord2> parsed2 = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString2));
+
+      if (parsed.FileComment == "This is a file comment\nOne more file comment line" && parsed2.FileComment == null)
+      {
+        Console.WriteLine($"Passed {testName}");
+      }
+      else
+      {
+        Console.WriteLine($"Failed {testName}");
+      }
+    }
+
+    {
+      string testName = "With and without types";
+
+      string testString1 = "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\nTRUE\tvalue\\\\twoo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther";
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed = SaneTsv.ParseTypedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Passed {testName} 1A");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Failed {testName} 1A");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed2 = SaneTsv.ParseSimpleTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1B");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1B");
+      }
+
+      try
+      {
+        (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1C");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1C");
+      }
+
+      string testString2 = "column1\tcolumn2\tcolumnthree\\nyep" +
+        "\nTRUE\tvalue\\\\twoo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther";
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed = SaneTsv.ParseTypedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 2A");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 2A");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed2 = SaneTsv.ParseSimpleTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 2B");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 2B");
+      }
+
+      try
+      {
+        (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 2C");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 2C");
+      }
+    }
+
+    {
+      string testName = "With and without line comment";
+
+      string testString1 = "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\n#This is a comment" +
+        "\n#Another comment line" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther";
+
+      try
+      {
+        CommentedTsv<BoolTestRecord2> parsed = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Passed {testName} 1A");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Failed {testName} 1A");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed = SaneTsv.ParseTypedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1B");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1B");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed2 = SaneTsv.ParseSimpleTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1C");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1C");
+      }
+
+      try
+      {
+        (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1D");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1D");
+      }
+    }
+
+    {
+      string testName = "End of file comment";
+
+      string testString1 = "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther" +
+        "\n# Hey, you're not supposed to have comments at the end of the tsv!";
+
+      try
+      {
+        CommentedTsv<BoolTestRecord2> parsed = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1A");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1A");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed = SaneTsv.ParseTypedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1B");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1B");
+      }
+
+      string testString2 = "column1\tcolumn2\tcolumnthree\\nyep" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther" +
+        "\n# Hey, you're not supposed to have comments at the end of the tsv!";
+
+      try
+      {
+        Tsv<BoolTestRecord3> parsed3 = SaneTsv.ParseSimpleTsv<BoolTestRecord3>(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 1C");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1C");
+      }
+
+      try
+      {
+        (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 1D");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1D");
+      }
+    }
+
+    {
+      string testName = "Partial parsing";
+
+      string line1 = "column1\tcolumn2\tcolumnthree\\nyep";
+      string line2 = "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee";
+      string line3 = "\nFALSE\tnother\tno\\ther";
+
+      byte[] inputBuffer = Encoding.UTF8.GetBytes(line1 + line2 + line3);
+
+      var headerTypes = new List<Type>();
+      var headerNames = new List<string>();
+      var headerPropertyInfos = new List<PropertyInfo>();
+      int columnCount = 0;
+
+      foreach (PropertyInfo property in typeof(BoolTestRecord3).GetProperties())
+      {
+        TsvColumnAttribute attribute = (TsvColumnAttribute)Attribute.GetCustomAttribute(property, typeof(TsvColumnAttribute));
+        if (attribute == null)
+        {
+          continue;
+        }
+
+        headerNames.Add(attribute.ColumnName ?? property.Name);
+        headerTypes.Add(attribute.ColumnType ?? GetColumnFromType(property.PropertyType));
+        headerPropertyInfos.Add(property);
+        // TODO: Check that the property type and given column type are compatible
+        columnCount++;
+      }
+
+      BoolTestRecord3[] records = SaneTsv.Parse<BoolTestRecord3>(inputBuffer, 
+        FormatType.SIMPLE_TSV,
+        headerPropertyInfos.ToArray(),
+        headerTypes.ToArray(),
+        line1.Length + line2.Length + 1,
+        inputBuffer.Length);
+
+      if (records.Length == 0 )
+      {
+        Console.WriteLine($"Passed {testName} 1");
+      }
+      else
+      {
+        Console.WriteLine($"Failed {testName} 1");
+      }
+
+      BoolTestRecord3[] records2 = SaneTsv.Parse<BoolTestRecord3>(inputBuffer, 
+        FormatType.SIMPLE_TSV,
+        headerPropertyInfos.ToArray(),
+        headerTypes.ToArray(),
+        line1.Length,
+        line1.Length + 3);
+
+      if (records2[0].Column3 == "valuetrhee")
+      {
+        Console.WriteLine($"Passed {testName} 2");
+      }
+      else
+      {
+        Console.WriteLine($"Failed {testName} 2");
+      }
+
+      string[][] data = SaneTsv.ParseSimpleTsv(inputBuffer, 3, line1.Length + line2.Length + 1, inputBuffer.Length);
+
+      if (data[0][1] == "nother")
+      {
+        Console.WriteLine($"Passed {testName} 3");
+      }
+      else
+      {
+        Console.WriteLine($"Failed {testName} 3");
+      }
+
+      string[][] data2 = SaneTsv.ParseSimpleTsv(inputBuffer, 3, line1.Length, line1.Length + 3);
+
+      if (data2.Length == 0)
+      {
+        Console.WriteLine($"Passed {testName} 4");
+      }
+      else
+      {
+        Console.WriteLine($"Failed {testName} 4");
+      }
+    }
+
+    {
+      string testName = "End of file \\n";
+
+      string testString1 = "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther" +
+        "\n";
+
+      try
+      {
+        CommentedTsv<BoolTestRecord2> parsed = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1A");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1A");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed = SaneTsv.ParseTypedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1B");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1B");
+      }
+
+      string testString2 = "column1\tcolumn2\tcolumnthree\\nyep" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther" +
+        "\n";
+
+      try
+      {
+        Tsv<BoolTestRecord3> parsed3 = SaneTsv.ParseSimpleTsv<BoolTestRecord3>(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 1C");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1C");
+      }
+
+      try
+      {
+        (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 1D");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1D");
+      }
+    }
+
+    {
+      string testName = "End of file partial record";
+
+      string testString1 = "column1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther" +
+        "\nTRUE\t";
+
+      try
+      {
+        CommentedTsv<BoolTestRecord2> parsed = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1A");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1A");
+      }
+
+      try
+      {
+        Tsv<BoolTestRecord2> parsed = SaneTsv.ParseTypedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+        Console.WriteLine($"Failed {testName} 1B");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1B");
+      }
+
+      string testString2 = "column1\tcolumn2\tcolumnthree\\nyep" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther" +
+        "\nTRUE\t";
+
+      try
+      {
+        Tsv<BoolTestRecord3> parsed3 = SaneTsv.ParseSimpleTsv<BoolTestRecord3>(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 1C");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1C");
+      }
+
+      try
+      {
+        (string[] columns, string[][] data) = SaneTsv.ParseSimpleTsv(Encoding.UTF8.GetBytes(testString2));
+        Console.WriteLine($"Failed {testName} 1D");
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine($"Passed {testName} 1D");
+      }
+    }
+
+    {
+      string testName = "File comment serde";
+
+      string testString1 = "#this is a file comment" +
+        "\n# and one more line since you're such a good customer" +
+        "\ncolumn1:type:boolean\tcolumn2:binary\tcolumnthree\\nyep:string" +
+        "\nTRUE\tvalue\\\\t\0woo\tvaluetrhee" +
+        "\nFALSE\tnother\tno\\ther";
+
+
+      CommentedTsv<BoolTestRecord2> parsed = SaneTsv.ParseCommentedTsv<BoolTestRecord2>(Encoding.UTF8.GetBytes(testString1));
+
+      string reserialized = Encoding.UTF8.GetString(SaneTsv.SerializeCommentedTsv<BoolTestRecord2>(parsed.Records, parsed.FileComment));
+
+      if (reserialized == testString1)
+      {
+        Console.WriteLine($"Passed {testName}");
+      }
+      else
+      {
+        Console.WriteLine($"Failed {testName}");
+      }
+    }
+
     Console.WriteLine("Done with tests");
   }
 }

readme.md

@@ -3,14 +3,43 @@
 ## Roadmap
 
 - Improve error reporting by including line/column information in exceptions
-- Come up with a static-typing interface
+  - Use this to get line numbers for parallel parsing implementations
+- [x] Come up with a static-typing interface
+
   Something that doesn't require an array of objects
+
+  Use a class with SaveTsv attributes
+
 - Check numeric formatting matches spec
-- Do parallel parsing / serializing implementation
-  - Next task: Refactor parsing so that it will start and end at arbitrary indices and return an array of SaneTsvRecords. The refactor should ignore the current record (unless at the start of the buffer) and continue parsing the record the end index is in.
-- More optimization and making parsing modular:
+- [x] Maybe add a binary representation for f32/f64. It should specify that it is Little-endian (since we have to pick one). That way we can guarantee bit-compatibility between implementations where an application might require that.
+- [x] Add Column name/type specification to API
+  - So you can tell it what columns to expect
+  - [ ] Lax/strict versions
+  
+  See the attributes thing above
+- Generate test cases
+  - [x] File comment / no file comment
+  - [x] header types / no header types
+  - [x] Line comments / no line comments
+  - [x] end of file comment
+  - [x] Test with the start index of parallel methods in last record
+    - end index in first record
+  - [x] Extra \n at end of file
+  - [x] Wrong number of fields
+    - Wrong number of fields at end of file
+
+- [x] Do parallel parsing / serializing implementation
+  - [x] Next task: Refactor parsing so that it will start and end at arbitrary indices and return an array of SaneTsvRecords. The refactor should ignore the current record (unless at the start of the buffer) and continue parsing the record the end index is in.
+- ~~More optimization and making parsing modular:~~
   - Have callbacks for header parsing and field parsing
   - That way other formats (like ExtraTSV) don't have to iterate through the entire set of data again.
-- Finish ExtraTSV implementation
-- Do zig implementation
+- [x] Make untyped Simple TSV (De)serialization
+- [x] ~~Finish~~ Minimal ExtraTSV implementation
+- [ ] Do zig implementation
 - Make a c interface from that
+- Make a commandline interface
+- Make a viewer / editor
+- Streaming interface
+  So you can start processing your data while it finishes parsing?
+- [ ] Decoding a binary stream with a \0 in it via UTF-8 doesn't seem to cause any issues. I thought that valid UTF-8 wouldn't have a \0?
+- [ ] Instead of exceptions when parsing, we should parse as much as possible and reflect parsing errors in the returned data structure