Add stew/enums and enumStrValues{Array,Seq}

.github/workflows/ci.yml

@@ -155,6 +155,7 @@ jobs:
           fi
           nim --version
           nimble --version
+          nimble install -y --depsOnly
           env TEST_LANG=c nimble test
           env TEST_LANG=cpp nimble test
 
@@ -173,5 +174,6 @@ jobs:
       - name: Test using VCC
         if: runner.os == 'Windows'
         run: |
+          export NIMFLAGS="-d:nimRawSetjmp"
           env TEST_LANG=c nimble testvcc
           env TEST_LANG=cpp nimble testvcc

stew.nimble

@@ -7,7 +7,8 @@ description   = "Backports, standard library candidates and small utilities that
 license       = "Apache License 2.0"
 skipDirs      = @["tests"]
 
-requires "nim >= 1.2.0"
+requires "nim >= 1.2.0",
+         "unittest2"
 
 ### Helper functions
 proc test(args, path: string) =

stew/enums.nim

@@ -0,0 +1,58 @@
+import
+  macros, sequtils
+
+macro enumRangeInt64*(a: type[enum]): untyped =
+  ## This macro returns an array with all the ordinal values of an enum
+  let
+    values = a.getType[1][1..^1]
+    valuesOrded = values.mapIt(newCall("int64", it))
+  newNimNode(nnkBracket).add(valuesOrded)
+
+macro enumStrValuesArrayImpl(a: type[enum]): untyped =
+  ## This macro returns an array with all the ordinal values of an enum
+  let
+    values = a.getType[1][1..^1]
+    valuesOrded = values.mapIt(newCall("$", it))
+  newNimNode(nnkBracket).add(valuesOrded)
+
+# TODO: This should be a proc returning a lent view over the
+#       const value. This will ensure only a single instace
+#       of the array is generated.
+template enumStrValuesArray*(E: type[enum]): auto =
+  const values = enumStrValuesArrayImpl E
+  values
+
+# TODO: This should be a proc returning a lent view over the
+#       const value. This will ensure only a single instace
+#       of the sequence is generated.
+template enumStrValuesSeq*(E: type[enum]): seq[string] =
+  const values = @(enumStrValuesArray E)
+  values
+
+macro hasHoles*(T: type[enum]): bool =
+  # As an enum is always sorted, just substract the first and the last ordinal value
+  # and compare the result to the number of element in it will do the trick.
+  let len = T.getType[1].len - 2
+
+  quote: `T`.high.ord - `T`.low.ord != `len`
+
+proc contains*[I: SomeInteger](e: type[enum], v: I): bool =
+  when I is uint64:
+    if v > int.high.uint64:
+      return false
+  when e.hasHoles():
+    v.int64 in enumRangeInt64(e)
+  else:
+    v.int64 in e.low.int64 .. e.high.int64
+
+func checkedEnumAssign*[E: enum, I: SomeInteger](res: var E, value: I): bool =
+  ## This function can be used to safely assign a tainted integer value (coming
+  ## from untrusted source) to an enum variable. The function will return `true`
+  ## if the integer value is within the acceped values of the enum and `false`
+  ## otherwise.
+
+  if value notin E:
+    return false
+
+  res = E value
+  return true

stew/objects.nim

@@ -1,6 +1,11 @@
 import
-  macros,
-  sequtils
+  macros, sequtils
+
+import
+  enums
+
+export
+  enums
 
 template init*(lvalue: var auto) =
   mixin init
@@ -68,41 +73,6 @@ proc baseType*(obj: RootObj): cstring =
 proc baseType*(obj: ref RootObj): cstring =
   obj[].baseType
 
-macro enumRangeInt64*(a: type[enum]): untyped =
-  ## This macro returns an array with all the ordinal values of an enum
-  let
-    values = a.getType[1][1..^1]
-    valuesOrded = values.mapIt(newCall("int64", it))
-  newNimNode(nnkBracket).add(valuesOrded)
-
-macro hasHoles*(T: type[enum]): bool =
-  # As an enum is always sorted, just substract the first and the last ordinal value
-  # and compare the result to the number of element in it will do the trick.
-  let len = T.getType[1].len - 2
-
-  quote: `T`.high.ord - `T`.low.ord != `len`
-
-proc contains*[I: SomeInteger](e: type[enum], v: I): bool =
-  when I is uint64:
-    if v > int.high.uint64:
-      return false
-  when e.hasHoles():
-    v.int64 in enumRangeInt64(e)
-  else:
-    v.int64 in e.low.int64 .. e.high.int64
-
-func checkedEnumAssign*[E: enum, I: SomeInteger](res: var E, value: I): bool =
-  ## This function can be used to safely assign a tainted integer value (coming
-  ## from untrusted source) to an enum variable. The function will return `true`
-  ## if the integer value is within the acceped values of the enum and `false`
-  ## otherwise.
-
-  if value notin E:
-    return false
-
-  res = E value
-  return true
-
 func isZeroMemory*[T](x: T): bool =
   # TODO: iterate over words here
   for b in cast[ptr array[sizeof(T), byte]](unsafeAddr x)[]:

tests/all_tests.nim

@@ -20,6 +20,7 @@ import
   test_byteutils,
   test_ctops,
   test_endians2,
+  test_enums,
   test_io2,
   test_keyed_queue,
   test_sorted_set,

tests/ranges/tbitranges.nim

@@ -1,5 +1,6 @@
 import
-  random, unittest,
+  random,
+  unittest2,
   ../../stew/ranges/bitranges, ../../stew/bitseqs
 
 proc randomBytes(n: int): seq[byte] =

tests/ranges/tstackarrays.nim

@@ -1,5 +1,6 @@
 import
-  unittest, math,
+  math,
+  unittest2,
   ../../stew/ptrops,
   ../../stew/ranges/[stackarrays]
 

tests/ranges/ttypedranges.nim

@@ -1,5 +1,6 @@
 import
-  unittest, sets,
+  sets,
+  unittest2,
   ../../stew/ranges/[typedranges, ptr_arith]
 
 suite "Typed ranges":

tests/test_arrayops.nim

@@ -10,7 +10,7 @@
 {.used.}
 
 import
-  std/unittest,
+  unittest2,
   ../stew/arrayops
 
 suite "arrayops":

tests/test_assign2.nim

@@ -1,5 +1,5 @@
 import
-  std/unittest,
+  unittest2,
   ../stew/assign2
 
 suite "assign2":

tests/test_base10.nim

@@ -1,5 +1,6 @@
-import unittest
-import ../stew/base10
+import
+  unittest2,
+  ../stew/base10
 
 when defined(nimHasUsed): {.used.}
 

tests/test_base32.nim

@@ -1,5 +1,6 @@
-import unittest
-import ../stew/base32
+import
+  unittest2,
+  ../stew/base32
 
 when defined(nimHasUsed): {.used.}
 

tests/test_base58.nim

@@ -1,5 +1,6 @@
-import unittest
-import ../stew/base58
+import
+  unittest2,
+  ../stew/base58
 
 when defined(nimHasUsed): {.used.}
 

tests/test_base64.nim

@@ -1,5 +1,6 @@
-import unittest
-import ../stew/[base64, byteutils]
+import
+  unittest2,
+  ../stew/[base64, byteutils]
 
 when defined(nimHasUsed): {.used.}
 

tests/test_bitops2.nim

@@ -1,6 +1,6 @@
-import unittest
-
-import ../stew/bitops2
+import
+  unittest2,
+  ../stew/bitops2
 
 template test() =
   doAssert bitsof(8'u8) == 8

tests/test_bitseqs.nim

@@ -1,5 +1,6 @@
 import
-  unittest, strformat,
+  strformat,
+  unittest2,
   ../stew/[bitseqs]
 
 suite "Bit fields":

tests/test_byteutils.nim

@@ -6,7 +6,7 @@
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
 import
-  std/unittest,
+  unittest2,
   ../stew/byteutils
 
 proc compilationTest {.exportc: "compilationTest".} =

tests/test_ctops.nim

@@ -1,5 +1,6 @@
-import unittest
-import ../stew/ctops
+import
+  unittest2,
+  ../stew/ctops
 
 suite "Constant-time operations test suite":
   test "isEqual() test":

tests/test_endians2.nim

@@ -1,6 +1,6 @@
-import unittest
-
-import ../stew/endians2
+import
+  unittest2,
+  ../stew/endians2
 
 template test() =
   doAssert 0x01'u8.toBytesBE == [0x01'u8]