2018-06-16 11:46:02 +00:00
|
|
|
import ./ptr_arith, typetraits, hashes
|
2018-03-26 12:52:48 +00:00
|
|
|
|
|
|
|
const rangesGCHoldEnabled = not defined(rangesDisableGCHold)
|
2018-06-21 08:37:29 +00:00
|
|
|
const unsafeAPIEnabled* = defined(rangesEnableUnsafeAPI)
|
2018-03-26 12:52:48 +00:00
|
|
|
|
|
|
|
type
|
|
|
|
# A view into immutable array
|
|
|
|
Range* {.shallow.} [T] = object
|
|
|
|
when rangesGCHoldEnabled:
|
|
|
|
gcHold: seq[T]
|
|
|
|
start: ptr T
|
2018-08-27 12:20:30 +00:00
|
|
|
mLen: int
|
2018-03-26 12:52:48 +00:00
|
|
|
|
|
|
|
# A view into mutable array
|
2018-08-30 10:20:46 +00:00
|
|
|
MutRange* {.shallow.} [T] = distinct Range[T]
|
2018-03-26 12:52:48 +00:00
|
|
|
|
2018-06-20 16:45:10 +00:00
|
|
|
ByteRange* = Range[byte]
|
|
|
|
MutByteRange* = MutRange[byte]
|
|
|
|
|
2018-08-27 15:53:34 +00:00
|
|
|
proc isLiteral[T](s: seq[T]): bool {.inline.} =
|
|
|
|
type
|
|
|
|
SeqHeader = object
|
|
|
|
length, reserved: int
|
|
|
|
(cast[ptr SeqHeader](s).reserved and (1 shl (sizeof(int) * 8 - 2))) != 0
|
|
|
|
|
2018-03-26 12:52:48 +00:00
|
|
|
proc toImmutableRange[T](a: seq[T]): Range[T] =
|
|
|
|
if a.len != 0:
|
|
|
|
when rangesGCHoldEnabled:
|
2018-08-27 15:53:34 +00:00
|
|
|
if not isLiteral(a):
|
|
|
|
shallowCopy(result.gcHold, a)
|
|
|
|
else:
|
|
|
|
result.gcHold = a
|
2018-06-15 11:06:52 +00:00
|
|
|
result.start = addr result.gcHold[0]
|
2018-08-27 12:20:30 +00:00
|
|
|
result.mLen = a.len
|
2018-03-26 12:52:48 +00:00
|
|
|
|
|
|
|
when unsafeAPIEnabled:
|
|
|
|
proc toImmutableRangeNoGCHold[T](a: openarray[T]): Range[T] =
|
|
|
|
if a.len != 0:
|
|
|
|
result.start = unsafeAddr a[0]
|
2018-08-27 12:20:30 +00:00
|
|
|
result.mLen = a.len
|
2018-03-26 12:52:48 +00:00
|
|
|
|
|
|
|
proc toImmutableRange[T](a: openarray[T]): Range[T] {.inline.} =
|
|
|
|
toImmutableRangeNoGCHold(a)
|
|
|
|
|
|
|
|
proc toRange*[T](a: var seq[T]): MutRange[T] {.inline.} =
|
|
|
|
MutRange[T](toImmutableRange(a))
|
|
|
|
|
|
|
|
when unsafeAPIEnabled:
|
|
|
|
proc toRange*[T](a: var openarray[T]): MutRange[T] {.inline.} =
|
|
|
|
MutRange[T](toImmutableRange(a))
|
|
|
|
|
|
|
|
template initStackRange*[T](sz: static[int]): MutRange[T] =
|
|
|
|
var data: array[sz, T]
|
|
|
|
data.toRange()
|
|
|
|
|
|
|
|
proc toRange*[T](a: openarray[T]): Range[T] {.inline.} = toImmutableRange(a)
|
|
|
|
|
2018-06-21 08:37:29 +00:00
|
|
|
proc unsafeRangeConstruction*[T](a: var openarray[T]): MutRange[T] {.inline.} =
|
|
|
|
MutRange[T](toImmutableRange(a))
|
|
|
|
|
|
|
|
proc unsafeRangeConstruction*[T](a: openarray[T]): Range[T] {.inline.} =
|
|
|
|
toImmutableRange(a)
|
|
|
|
|
2018-03-26 12:52:48 +00:00
|
|
|
proc newRange*[T](sz: int): MutRange[T] {.inline.} =
|
|
|
|
MutRange[T](toImmutableRange(newSeq[T](sz)))
|
|
|
|
|
|
|
|
proc toRange*[T](a: seq[T]): Range[T] {.inline.} = toImmutableRange(a)
|
|
|
|
|
|
|
|
converter toImmutableRange*[T](a: MutRange[T]): Range[T] {.inline.} = Range[T](a)
|
|
|
|
|
|
|
|
proc len*(r: Range): int {.inline.} = int(r.mLen)
|
|
|
|
|
|
|
|
proc high*(r: Range): int {.inline.} = r.len - 1
|
|
|
|
proc low*(r: Range): int {.inline.} = 0
|
|
|
|
|
|
|
|
proc elemAt[T](r: MutRange[T], idx: int): var T {.inline.} =
|
|
|
|
assert(idx < r.len)
|
|
|
|
Range[T](r).start.shift(idx)[]
|
|
|
|
|
|
|
|
proc `[]=`*[T](r: MutRange[T], idx: int, v: T) {.inline.} = r.elemAt(idx) = v
|
|
|
|
proc `[]`*[T](r: MutRange[T], i: int): var T = r.elemAt(i)
|
|
|
|
|
|
|
|
proc `[]`*[T](r: Range[T], idx: int): T {.inline.} =
|
|
|
|
assert(idx < r.len)
|
|
|
|
r.start.shift(idx)[]
|
|
|
|
|
2018-06-06 15:53:02 +00:00
|
|
|
proc `==`*[T](a, b: Range[T]): bool =
|
|
|
|
if a.len != b.len: return false
|
|
|
|
equalMem(a.start, b.start, sizeof(T) * a.len)
|
|
|
|
|
2018-03-26 12:52:48 +00:00
|
|
|
iterator ptrs[T](r: Range[T]): (int, ptr T) =
|
|
|
|
var p = r.start
|
|
|
|
var i = 0
|
|
|
|
let e = r.len
|
|
|
|
while i != e:
|
|
|
|
yield (i, p)
|
|
|
|
p = p.shift(1)
|
|
|
|
inc i
|
|
|
|
|
|
|
|
iterator items*[T](r: Range[T]): T =
|
|
|
|
for _, v in ptrs(r): yield v[]
|
|
|
|
|
|
|
|
iterator pairs*[T](r: Range[T]): (int, T) =
|
|
|
|
for i, v in ptrs(r): yield (i, v[])
|
|
|
|
|
|
|
|
iterator mitems*[T](r: MutRange[T]): var T =
|
|
|
|
for _, v in ptrs(r): yield v[]
|
|
|
|
|
|
|
|
iterator mpairs*[T](r: MutRange[T]): (int, var T) =
|
|
|
|
for i, v in ptrs(r): yield (i, v[])
|
|
|
|
|
|
|
|
proc toSeq*[T](r: Range[T]): seq[T] =
|
|
|
|
result = newSeqOfCap[T](r.len)
|
|
|
|
for i in r: result.add(i)
|
|
|
|
|
|
|
|
proc `$`*(r: Range): string =
|
|
|
|
result = "R["
|
|
|
|
for i, v in r:
|
|
|
|
if i != 0:
|
|
|
|
result &= ", "
|
|
|
|
result &= $v
|
|
|
|
result &= "]"
|
|
|
|
|
|
|
|
proc sliceNormalized[T](r: Range[T], ibegin, iend: int): Range[T] =
|
2018-06-23 13:25:33 +00:00
|
|
|
assert ibegin >= 0 and
|
|
|
|
ibegin < r.len and
|
|
|
|
iend < r.len and
|
|
|
|
iend + 1 >= ibegin # the +1 here allows the result to be
|
|
|
|
# an empty range
|
|
|
|
|
2018-03-26 12:52:48 +00:00
|
|
|
when rangesGCHoldEnabled:
|
2018-08-30 10:20:46 +00:00
|
|
|
shallowCopy(result.gcHold, r.gcHold)
|
2018-03-26 12:52:48 +00:00
|
|
|
result.start = r.start.shift(ibegin)
|
2018-08-27 12:20:30 +00:00
|
|
|
result.mLen = iend - ibegin + 1
|
2018-03-26 12:52:48 +00:00
|
|
|
|
|
|
|
proc slice*[T](r: Range[T], ibegin = 0, iend = -1): Range[T] =
|
|
|
|
let e = if iend < 0: r.len + iend
|
|
|
|
else: iend
|
|
|
|
sliceNormalized(r, ibegin, e)
|
|
|
|
|
|
|
|
proc slice*[T](r: MutRange[T], ibegin = 0, iend = -1): MutRange[T] {.inline.} =
|
|
|
|
MutRange[T](Range[T](r).slice(ibegin, iend))
|
|
|
|
|
|
|
|
template `^^`(s, i: untyped): untyped =
|
|
|
|
(when i is BackwardsIndex: s.len - int(i) else: int(i))
|
|
|
|
|
|
|
|
proc `[]`*[T, U, V](r: Range[T], s: HSlice[U, V]): Range[T] {.inline.} =
|
|
|
|
sliceNormalized(r, r ^^ s.a, r ^^ s.b)
|
|
|
|
|
|
|
|
proc `[]`*[T, U, V](r: MutRange[T], s: HSlice[U, V]): MutRange[T] {.inline.} =
|
|
|
|
MutRange[T](sliceNormalized(r, r ^^ s.a, r ^^ s.b))
|
|
|
|
|
|
|
|
proc `[]=`*[T, U, V](r: MutRange[T], s: HSlice[U, V], v: openarray[T]) =
|
|
|
|
let a = r ^^ s.a
|
|
|
|
let b = r ^^ s.b
|
|
|
|
let L = b - a + 1
|
|
|
|
if L == v.len:
|
|
|
|
for i in 0..<L: r[i + a] = v[i]
|
|
|
|
else:
|
|
|
|
raise newException(RangeError, "different lengths for slice assignment")
|
|
|
|
|
2018-04-11 11:26:46 +00:00
|
|
|
template toOpenArray*[T](r: Range[T]): auto =
|
2018-11-07 00:08:53 +00:00
|
|
|
toOpenArray(cast[ptr UncheckedArray[T]](r.start), 0, r.high)
|
2018-04-11 11:26:46 +00:00
|
|
|
|
2018-03-26 12:52:48 +00:00
|
|
|
proc `[]=`*[T, U, V](r: MutRange[T], s: HSlice[U, V], v: Range[T]) {.inline.} =
|
|
|
|
r[s] = toOpenArray(v)
|
|
|
|
|
|
|
|
proc baseAddr*[T](r: Range[T]): ptr T {.inline.} = r.start
|
2018-08-30 10:20:46 +00:00
|
|
|
proc gcHolder*[T](r: Range[T]): ptr T {.inline.} =
|
|
|
|
## This procedure is used only for shallow test, do not use it
|
|
|
|
## in production.
|
|
|
|
when rangesGCHoldEnabled:
|
|
|
|
if r.len > 0:
|
|
|
|
result = unsafeAddr r.gcHold[0]
|
2018-06-07 15:26:08 +00:00
|
|
|
template toRange*[T](a: Range[T]): Range[T] = a
|
|
|
|
|
2018-06-08 03:07:47 +00:00
|
|
|
# this preferred syntax doesn't work
|
|
|
|
# see https://github.com/nim-lang/Nim/issues/7995
|
|
|
|
#template copyRange[T](dest: seq[T], destOffset: int, src: Range[T]) =
|
|
|
|
# when supportsCopyMem(T):
|
|
|
|
|
|
|
|
template copyRange[T](E: typedesc, dest: seq[T], destOffset: int, src: Range[T]) =
|
|
|
|
when supportsCopyMem(E):
|
2018-06-12 09:00:45 +00:00
|
|
|
if dest.len != 0 and src.len != 0:
|
|
|
|
copyMem(dest[destOffset].unsafeAddr, src.start, sizeof(T) * src.len)
|
2018-06-08 03:07:47 +00:00
|
|
|
else:
|
|
|
|
for i in 0..<src.len:
|
|
|
|
dest[i + destOffset] = src[i]
|
|
|
|
|
2018-06-07 15:26:08 +00:00
|
|
|
proc concat*[T](v: varargs[Range[T], toRange]): seq[T] =
|
|
|
|
var len = 0
|
|
|
|
for c in v: inc(len, c.len)
|
|
|
|
result = newSeq[T](len)
|
|
|
|
len = 0
|
|
|
|
for c in v:
|
2018-06-08 03:07:47 +00:00
|
|
|
copyRange(T, result, len, c)
|
2018-06-07 15:26:08 +00:00
|
|
|
inc(len, c.len)
|
|
|
|
|
|
|
|
proc `&`*[T](a, b: Range[T]): seq[T] =
|
|
|
|
result = newSeq[T](a.len + b.len)
|
2018-06-08 03:07:47 +00:00
|
|
|
copyRange(T, result, 0, a)
|
|
|
|
copyRange(T, result, a.len, b)
|
2018-06-17 00:20:46 +00:00
|
|
|
|
|
|
|
proc hash*(x: Range): Hash =
|
|
|
|
result = hash(toOpenArray(x))
|
2018-08-27 12:20:30 +00:00
|
|
|
|
|
|
|
template advanceImpl(a, b: untyped): bool =
|
|
|
|
var res = false
|
|
|
|
if b == 0:
|
|
|
|
res = true
|
|
|
|
elif b > 0:
|
|
|
|
if isNil(a.start) or a.mLen <= 0:
|
|
|
|
res = false
|
|
|
|
else:
|
|
|
|
if a.mLen - b < 0:
|
|
|
|
res = false
|
|
|
|
else:
|
|
|
|
a.start = a.start.shift(b)
|
|
|
|
a.mLen -= b
|
|
|
|
res = true
|
|
|
|
res
|
|
|
|
|
|
|
|
proc tryAdvance*[T](x: var Range[T], idx: int): bool =
|
|
|
|
## Move internal start offset of range ``x`` by ``idx`` elements forward.
|
2018-08-27 14:37:39 +00:00
|
|
|
##
|
2018-08-27 12:20:30 +00:00
|
|
|
## Returns ``true`` if operation got completed successfully, or
|
2018-08-27 14:37:39 +00:00
|
|
|
## ``false`` if you are trying to overrun range ``x``.
|
2018-08-27 12:20:30 +00:00
|
|
|
result = x.advanceImpl(idx)
|
|
|
|
|
2018-08-27 14:37:39 +00:00
|
|
|
proc tryAdvance*[T](x: var MutRange[T], idx: int): bool {.inline.} =
|
2018-08-27 12:20:30 +00:00
|
|
|
## Move internal start offset of range ``x`` by ``idx`` elements forward.
|
2018-08-27 14:37:39 +00:00
|
|
|
##
|
2018-08-27 12:20:30 +00:00
|
|
|
## Returns ``true`` if operation got completed successfully, or
|
2018-08-27 14:37:39 +00:00
|
|
|
## ``false`` if you are trying to overrun range ``x``.
|
|
|
|
result = tryAdvance(Range[T](x), idx)
|
2018-08-27 12:20:30 +00:00
|
|
|
|
|
|
|
proc advance*[T](x: var Range[T], idx: int) =
|
|
|
|
## Move internal start offset of range ``x`` by ``idx`` elements forward.
|
|
|
|
let res = x.advanceImpl(idx)
|
|
|
|
if not res: raise newException(IndexError, "Advance Error")
|
|
|
|
|
2018-08-27 14:37:39 +00:00
|
|
|
proc advance*[T](x: var MutRange[T], idx: int) {.inline.} =
|
2018-08-27 12:20:30 +00:00
|
|
|
## Move internal start offset of range ``x`` by ``idx`` elements forward.
|
2018-08-27 14:37:39 +00:00
|
|
|
advance(Range[T](x), idx)
|