Add support for chars, sets and ordered table. Re-benchmark.

Author: treeform

README.md

@@ -17,12 +17,12 @@ Currently the Nim standard module first parses or serializes json into JsonNodes
 
 Another speed up comes from not using `StringStream`. Stream has a function dispatch overhead because it has to be able to switch between `StringStream` or `FileStream` at runtime. Jsony skips the overhead and just directly reads or writes to memory buffers.
 
-Another speed up comes from parsing and readings its own numbers directly from memory buffer. This allows it to by pass `string` allocations that `parseInt` or `$` create.
+Another speed up comes from parsing and readings its own numbers directly from memory buffer. This allows it to bypass `string` allocations that `parseInt` or `$` create.
 
 ### Parse speed.
 ```
 name ............................... min time      avg time    std dv  times
-treeform/jsony ..................... 6.311 ms      9.688 ms    ±3.301   x100
+treeform/jsony ..................... 6.724 ms     12.047 ms    ±3.694   x100
 status-im/nim-json-serialization ... 7.119 ms     14.276 ms    ±2.033   x100
 nim std/json ...................... 24.141 ms     38.741 ms    ±5.417   x100
 planetis-m/eminim ................. 10.974 ms     18.355 ms    ±3.994   x100
@@ -43,11 +43,14 @@ Note: If you find a faster nim json parser or serializer let me know!
 ## Can parse or serializer most types:
 
 * numbers and strings
+* seq and arrays
 * objects and ref objects
 * enums
 * tuples
-* seq and arrays
-* tables
+* characters
+* `HashTable`s and `OrderedTable`s
+* `HashSet`s and `OrderedSet`s
+* json nodes
 * and `parseHook()` enables you to parse any type!
 
 ## Not strict.

src/jsony.nim

@@ -1,4 +1,4 @@
-import jsony/objvar, strutils, tables, unicode, json
+import jsony/objvar, strutils, tables, sets, unicode, json
 
 type JsonError* = object of ValueError
 
@@ -7,13 +7,18 @@ const whiteSpace = {' ', '\n', '\t', '\r'}
 when defined(release):
   {.push checks: off.}
 
+type SomeTable*[K, V] = Table[K, V] | OrderedTable[K, V] |
+  TableRef[K, V] | OrderedTableRef[K, V]
+
 proc parseHook*[T](s: string, i: var int, v: var seq[T])
 proc parseHook*[T: enum](s: string, i: var int, v: var T)
 proc parseHook*[T: object|ref object](s: string, i: var int, v: var T)
-proc parseHook*[T](s: string, i: var int, v: var Table[string, T])
+proc parseHook*[T](s: string, i: var int, v: var SomeTable[string, T])
+proc parseHook*[T](s: string, i: var int, v: var SomeSet[T])
 proc parseHook*[T: tuple](s: string, i: var int, v: var T)
 proc parseHook*[T: array](s: string, i: var int, v: var T)
 proc parseHook*(s: string, i: var int, v: var JsonNode)
+proc parseHook*(s: string, i: var int, v: var char)
 
 template error(msg: string, i: int) =
   ## Shortcut to raise an exception.
@@ -147,6 +152,13 @@ proc parseHook*(s: string, i: var int, v: var string) =
     inc i
   eatChar(s, i, '"')
 
+proc parseHook*(s: string, i: var int, v: var char) =
+  var str: string
+  s.parseHook(i, str)
+  if str.len != 1:
+    error("String can't fit into a char.", i)
+  v = str[0]
+
 proc parseHook*[T](s: string, i: var int, v: var seq[T]) =
   ## Parse seq.
   eatChar(s, i, '[')
@@ -316,8 +328,10 @@ proc parseHook*[T: object|ref object](s: string, i: var int, v: var T) =
     postHook(v)
   eatChar(s, i, '}')
 
-proc parseHook*[T](s: string, i: var int, v: var Table[string, T]) =
+proc parseHook*[T](s: string, i: var int, v: var SomeTable[string, T]) =
   ## Parse an object.
+  when compiles(new(v)):
+    new(v)
   eatChar(s, i, '{')
   while i < s.len:
     eatSpace(s, i)
@@ -335,6 +349,22 @@ proc parseHook*[T](s: string, i: var int, v: var Table[string, T]) =
       break
   eatChar(s, i, '}')
 
+proc parseHook*[T](s: string, i: var int, v: var SomeSet[T]) =
+  ## Parse HashSet.
+  eatSpace(s, i)
+  eatChar(s, i, '[')
+  while true:
+    eatSpace(s, i)
+    if i < s.len and s[i] == ']':
+      break
+    var e: T
+    parseHook(s, i, e)
+    v.incl(e)
+    eatSpace(s, i)
+    if i < s.len and s[i] == ',':
+      inc i
+  eatChar(s, i, ']')
+
 proc parseHook*(s: string, i: var int, v: var JsonNode) =
   ## Parses a regular json node.
   eatSpace(s, i)
@@ -592,6 +622,16 @@ proc dumpHook*(s: var string, v: ref object) =
   else:
     s.dumpHook(v[])
 
+proc dumpHook*[T](s: var string, v: HashSet[T]|OrderedSet[T]) =
+  s.add '['
+  var i = 0
+  for e in v:
+    if i != 0:
+      s.add ','
+    s.dumpHook(e)
+    inc i
+  s.add ']'
+
 proc dumpHook*(s: var string, v: JsonNode) =
   ## Dumps a regular json node.
   case v.kind:

tests/test_char.nim

@@ -0,0 +1,7 @@
+import jsony
+
+doAssert """ "a" """.fromJson(char) == 'a'
+doAssert """["a"]""".fromJson(seq[char]) == @['a']
+doAssert """["a", "b", "c"]""".fromJson(seq[char]) == @['a', 'b', 'c']
+doAssert 'a'.toJson() == """"a""""
+doAssert 'b'.toJson() == """"b""""

tests/test_sets.nim

@@ -0,0 +1,12 @@
+import jsony, sets
+
+block:
+  let
+    s1 = toHashSet([9, 5, 1])
+    s2 = toOrderedSet([3, 5, 7])
+
+  doAssert s1.toJson() == "[9,1,5]"
+  doAssert s2.toJson() == "[3,5,7]"
+
+  doAssert s1.toJson.fromJson(type(s1)) == s1
+  doAssert s2.toJson.fromJson(type(s2)) == s2

tests/test_tables.nim

@@ -33,3 +33,17 @@ block:
   doAssert v["a"].color == "red"
   doAssert v["b"].color == "green"
   doAssert v["c"].color == "blue"
+
+block:
+  type Entry = object
+    color: string
+  var s = """{
+    "a": {"color":"red"},
+    "b": {"color":"green"},
+    "c": {"color":"blue"}
+  }"""
+  var v = s.fromJson(OrderedTableRef[string, Entry])
+  doAssert v.len == 3
+  doAssert v["a"].color == "red"
+  doAssert v["b"].color == "green"
+  doAssert v["c"].color == "blue"