SliceMem is a general purpose array that can be casted to any type, and does not create copies when assigned multiple times, like a reference type, unless you use copy. It can be created by itself, from another container such as a seq (without copying when possible), or from a pointer and a custom destructor.
It's called "SliceMem" because "MemSlice" is taken by std/memfiles.
Procs
proc concat[T](slices: varargs[SliceMem[T]]): SliceMem[T]
-
Concatenates a list of SliceMems into a single one. Contents are copied.
Example:
let a = @[1,2,3,4,5].toSliceMem let b = @[6,7,8,9,0].toSliceMem var x = concat(a,b) x = concat(a,b,a,a,b) # You can pass any amount of slices as arguments x = concat(@[b,b,a,a]) # or you can pass a seq
Source Edit proc copy[T](s: SliceMem[T]): SliceMem[T]
- Creates a copy of a SliceMem that doesn't reference the original one. Source Edit
proc deserialize[T](data: SliceMem[T]): seq[SliceMem[T]]
- Reverts the process done by serialize except the conversion to byte. You can convert to the appropriate type before or after deserialization with to (see example in serialize) Source Edit
proc newSliceMem(p: pointer; byte_len: int; destructor: proc () {.closure, ...raises: [].}): SliceMem[byte] {. inline, ...raises: [], tags: [RootEffect].}
- Create a SliceMem from a pointer without type, a length in bytes, and a destructor closure. Same as newSliceMemT but assumes type is byte. Source Edit
proc newSliceMem[T, U](container: sink U; first, last: pointer): SliceMem[T]
- Create a SliceMem from a container and the two pointers of the first and last elements in the container. Usually you will want to use toSliceMem instead. Source Edit
proc newSliceMem[T, U](container: sink U; p: pointer; byte_len: int): SliceMem[T]
-
Create a SliceMem from a container, a pointer, and a length in bytes.
Example:
let x = @[1,2,3,4,5] # You can omit the [int] here because the container is iterable let s = newSliceMem[int](x, x[0].addr, x.len * sizeof(x[0]))
Source Edit proc newSliceMem[T](p: ptr T; len: int; destructor: proc () {.closure, ...raises: [].}): SliceMem[T]
-
Example:
let x = createShared(int, 5) proc destroy() = deallocShared(x) let s = newSliceMem(x, 5, destroy)
Source Edit proc newSliceMem[T](size: int): SliceMem[T]
-
Create a SliceMem from new memory, similar to ArrRef[T].
Example:
let s = newSliceMem[int](10) for i,n in s.mpairs: n = (i+1)*11 doAssert $s == "SliceMem([11, 22, 33, 44, 55, 66, 77, 88, 99, 110])"
Source Edit proc serialize[T](slices: openArray[SliceMem[T]]; align = sizeof(int)): SliceMem[ byte]
-
Converts a list of SliceMems into a single segment of memory that can be later deserialized into the separate SliceMems again. Use deserialize for the inverse process. Use serializeToSeq to obtain the separate formatted slices before they're concatenated and avoid copies.
Example:
let a = @[1,2,3,4,5].toSliceMem let b = @[6,7,8,9,0].toSliceMem let serialized = serialize(@[a,b]) let slices = serialized.to(int).deserialize doAssert $slices == "@[SliceMem([1, 2, 3, 4, 5]), SliceMem([6, 7, 8, 9, 0])]"
Source Edit proc serializeToSeq[T](slices: openArray[SliceMem[T]]; align = sizeof(int)): seq[ SliceMem[byte]]
- Converts a list of SliceMems into a format that can be saved to file and deserialized later. See serialize and deserialize. This proc returns a seq that is ready to concatenate or to write to a file. Source Edit
Templates
template `&`[T, U](a: SliceMem[T]; b: SliceMem[U]): SliceMem[T]
- Concatenates two SliceMems (of any type) into a new one with the type of the first one. Source Edit
template newSliceMem(container: not pointer; p, byte_len: untyped): untyped
- Template to automatically determine the type for newSliceMem[T,U] Source Edit
template to[T](s: openArray[SliceMem]; typ: typedesc[T]): seq[SliceMem[T]]
- Cast a seq of SliceMems from one type to another Source Edit
template to[T](s: SliceMem; typ: typedesc[T]): SliceMem[T]
- Cast the SliceMem from one type to another Source Edit
template toOpenArray(s: SliceMem): untyped
- Source Edit
template toOpenArrayByte(s: SliceMem): untyped
- Source Edit
template toSliceMem(container): untyped
-
Create a SliceMem from a container, with all its contents. The container needs to have [] and items() (like seq). If it doesn't you need to pass pointers directly to newSliceMem instead.
Example:
var x = @[1,2,3,4,5] let a = x.toSliceMem let b = toSliceMem(move x) # This also works, and ensures that # the contents of x are not copied
Source Edit template toSliceMem(container, slice: untyped): untyped
-
Create a SliceMem from a container and a slice that indicates the range. The container needs to have [] and items() (like seq). If it doesn't you need to pass pointers directly to newSliceMem instead.
Example:
var x = @[1,2,3,4,5] let a = x.toSliceMem(1..3) let b = toSliceMem(move x, 1..3) # This also works, and ensures that # the contents of x are not copied
Source Edit