Author:	Kaushal Modi
License:	MIT

Introduction

Nim wrapper to map with the C++ std::vector library.

Source

Repo link

Types

Vector[T] {.importcpp: "std::vector".} = object
VectorIter[T] {.importcpp: "std::vector<\'0>::iterator".} = object
VectorConstIter[T] {.importcpp: "std::vector<\'0>::const_iterator".} = object
SizeType = csize_t

Procs

proc initVector[T](): Vector[T] {.importcpp: "std::vector<\'*0>()", constructor, header: "<vector>".}

proc initVector[T](size: SizeType): Vector[T] {. importcpp: "std::vector<\'*0>(#)", constructor, header: "<vector>".}

proc len(v: Vector): SizeType {.importcpp: "#.size()", header: "<vector>".}

Return the number of elements in the Vector.

This has an alias proc size.

https://en.cppreference.com/w/cpp/container/vector/size

Example:

var
  v = initVector[int]()
doAssert v.size() == 0

v.add(100)
v.add(200)
doAssert v.len() == 2

proc empty(v: Vector): bool {.importcpp: "empty", header: "<vector>".}

Check if the Vector is empty i.e. has zero elements.

https://en.cppreference.com/w/cpp/container/vector/empty

Example:

var
  v = initVector[int]()
doAssert v.empty()

v.add(100)
doAssert not v.empty()

proc `[]`[T](v: Vector[T]; idx: SizeType): var T {.importcpp: "#[#]", header: "<vector>".}

Return the reference to v[idx].

Example:

var
  v = initVector[char]()
v.add('a')
v.add('b')
v.add('c')

v[1] = 'z'
doAssert v[0] == 'a'
doAssert v[1] == 'z'
doAssert v[2] == 'c'

proc first[T](v: Vector[T]): var T {.importcpp: "front", header: "<vector>".}

Return the reference to the first element of the Vector.

This has an alias proc front.

https://en.cppreference.com/w/cpp/container/vector/front

Example:

var
  v = initVector[int]()

v.add(100)
v.add(200)
doAssert v.first() == 100

v.first() = 300
doAssert v.first() == 300
doAssert v.first() == v.front()

proc last[T](v: Vector[T]): var T {.importcpp: "back", header: "<vector>".}

Return the reference to the last element of the Vector.

This has an alias proc back.

https://www.cplusplus.com/reference/vector/vector/back/

Example:

var
  v = initVector[int]()

v.add(100)
v.add(200)
doAssert v.last() == 200

v.last() = 300
doAssert v.last() == 300
doAssert v.last() == v.back()

proc assign[T](v: var Vector[T]; num: SizeType; val: T) {. importcpp: "#.assign(@)", header: "<vector>".}

Return a Vector with num elements assigned to the specified value val.

https://en.cppreference.com/w/cpp/container/vector/assign

Example:

var
  v: Vector[float]

v.assign(5, 1.0)
doAssert v.toSeq() == @[1.0, 1.0, 1.0, 1.0, 1.0]

v.assign(2, 2.3)
doAssert v.toSeq() == @[2.3, 2.3]

proc `==`[T](a: Vector[T]; b: Vector[T]): bool {.importcpp: "# == #", header: "<vector>".}

Return true if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

https://en.cppreference.com/w/cpp/container/vector/operator_cmp

Example:

let
  v1 = @[1, 2, 3].toVector()
  v2 = v1
doAssert v1 == v2

proc `!=`[T](a: Vector[T]; b: Vector[T]): bool {.importcpp: "# != #", header: "<vector>".}

Return true if the contents of lhs and rhs are not equal, that is, either they do not have the same number of elements, or one of the elements in lhs does not compare equal with the element in rhs at the same position.

https://en.cppreference.com/w/cpp/container/vector/operator_cmp

Example:

let
  v1 = @[1, 2, 3].toVector()
var
  v2 = v1
  v3 = v1
v2.add(4)
doAssert v2 != v1

v3[0] = 100
doAssert v3 != v1

proc `<`[T](a: Vector[T]; b: Vector[T]): bool {.importcpp: "# < #", header: "<vector>".}

Return true if a is lexicographically less than b.

https://en.cppreference.com/w/cpp/container/vector/operator_cmp

Example:

let
  v1 = @[1, 2, 3].toVector()
var
  v2 = v1
doAssert not (v1 < v2)

v2.add(4)
doAssert v1 < v2

v2[2] = 0
doAssert v2 < v1

proc `<=`[T](a: Vector[T]; b: Vector[T]): bool {.importcpp: "# <= #", header: "<vector>".}

Return true if a is lexicographically less than or equal to b.

https://en.cppreference.com/w/cpp/container/vector/operator_cmp

Example:

let
  v1 = @[1, 2, 3].toVector()
var
  v2 = v1
doAssert v1 <= v2

v2.add(4)
doAssert v1 <= v2

v2[2] = 0
doAssert v2 <= v1

proc `>`[T](a: Vector[T]; b: Vector[T]): bool {.importcpp: "# > #", header: "<vector>".}

Return true if a is lexicographically greater than b.

https://en.cppreference.com/w/cpp/container/vector/operator_cmp

Example:

let
  v1 = @[1, 2, 3].toVector()
var
  v2 = v1
doAssert not (v2 > v1)

v2.add(4)
doAssert v2 > v1

v2[2] = 0
doAssert v1 > v2

proc `>=`[T](a: Vector[T]; b: Vector[T]): bool {.importcpp: "# >= #", header: "<vector>".}

Return true if a is lexicographically greater than or equal to b.

https://en.cppreference.com/w/cpp/container/vector/operator_cmp

Example:

let
  v1 = @[1, 2, 3].toVector()
var
  v2 = v1
doAssert v2 >= v1

v2.add(4)
doAssert v2 >= v1

v2[2] = 0
doAssert v1 >= v2

proc `+`[T: VectorIter | VectorConstIter](iter: T; offset: int): T {. importcpp: "# + #", header: "<vector>".}

Return an updated iterator pointing to the input iterator plus the specified offset.

Example:

var
  v = @[1.0, 2.0, 3.0].toVector()

discard v.insert(v.cBegin()+1, 1.5)
doAssert v.toSeq() == @[1.0, 1.5, 2.0, 3.0]

discard v.insert(v.begin()+3, 2.5)
doAssert v.toSeq() == @[1.0, 1.5, 2.0, 2.5, 3.0]

proc `-`[T: VectorIter | VectorConstIter](iter: T; offset: int): T {. importcpp: "# - #", header: "<vector>".}

Return an updated iterator pointing to the input iterator minus the specified offset.

Example:

var
  v = @[1.0, 2.0, 3.0].toVector()

discard v.insert(v.cEnd()-1, 2.5)
doAssert v.toSeq() == @[1.0, 2.0, 2.5, 3.0]

discard v.insert(v.`end`()-3, 1.5)
doAssert v.toSeq() == @[1.0, 1.5, 2.0, 2.5, 3.0]

proc begin[T](v: Vector[T]): VectorIter[T] {.importcpp: "begin", header: "<vector>".}

Return a mutable C++ iterator pointing to the beginning position of the Vector.

https://www.cplusplus.com/reference/vector/vector/begin/

Example:

var
  v = @[1, 2, 3].toVector()
discard v.insert(v.begin(), 100)
doAssert v.toSeq() == @[100, 1, 2, 3]

proc cBegin[T](v: Vector[T]): VectorConstIter[T] {.importcpp: "cbegin", header: "<vector>".}

Return an immutable C++ iterator pointing to the beginning position of the Vector.

https://www.cplusplus.com/reference/vector/vector/begin/

Example:

var
  v = @[1, 2, 3].toVector()
discard v.insert(v.cBegin(), 100)
doAssert v.toSeq() == @[100, 1, 2, 3]

proc `end`[T](v: Vector[T]): VectorIter[T] {.importcpp: "end", header: "<vector>".}

Return a mutable C++ iterator pointing to after the end position of the Vector.

https://www.cplusplus.com/reference/vector/vector/end/

Example:

var
  v = @[1, 2, 3].toVector()
discard v.insert(v.`end`(), 100)
doAssert v.toSeq() == @[1, 2, 3, 100]

proc cEnd[T](v: Vector[T]): VectorConstIter[T] {.importcpp: "cend", header: "<vector>".}

Return an immutable C++ iterator pointing to after the end position of the Vector.

https://www.cplusplus.com/reference/vector/vector/end/

Example:

var
  v = @[1, 2, 3].toVector()
discard v.insert(v.cEnd(), 100)
doAssert v.toSeq() == @[1, 2, 3, 100]

proc add[T](v: var Vector[T]; elem: T) {.importcpp: "#.push_back(#)", header: "<vector>".}

Append a new element to the end of the Vector.

This has an alias proc pushBack.

https://en.cppreference.com/w/cpp/container/vector/push_back

Example:

var
  v = initVector[int]()
doAssert v.len() == 0

v.add(100)
v.pushBack(200)
doAssert v.len() == 2

proc popBack[T](v: var Vector[T]) {.importcpp: "pop_back", header: "<vector>".}

Remove the last element of the Vector. This proc does not return anything.

https://www.cplusplus.com/reference/vector/vector/pop_back/

Example:

var
  v = initVector[int]()
doAssert v.len() == 0

v.add(100)
doAssert v.len() == 1

v.popBack()
doAssert v.len() == 0

proc insert[T](v: var Vector[T]; pos: VectorConstIter[T]; val: T): VectorIter[T] {. importcpp: "insert", header: "<vector>".}

Insert an element before the specified position.

Example:

var
  v = @['a', 'b'].toVector()
discard v.insert(v.cBegin(), 'c')
doAssert v.toSeq() == @['c', 'a', 'b']

proc insert[T](v: var Vector[T]; pos: VectorConstIter[T]; count: SizeType; val: T): VectorIter[T] {.importcpp: "insert", header: "<vector>".}

Insert count copies of element before the specified position.

Example:

var
  v = @['a', 'b'].toVector()
discard v.insert(v.cBegin(), 3, 'c')
doAssert v.toSeq() == @['c', 'c', 'c', 'a', 'b']

proc insert[T](v: var Vector[T]; pos, first, last: VectorConstIter[T]): VectorIter[ T] {.importcpp: "insert", header: "<vector>".}

Insert elements from range first ..< last before the specified position.

Example:

let
  v1 = @['a', 'b'].toVector()
var
  v2: Vector[char]
discard v2.insert(v2.cBegin(), v1.cBegin(), v1.cEnd())
doAssert v2.toSeq() == @['a', 'b']

proc swap[T](v1, v2: var Vector[T]) {.importcpp: "swap", header: "<vector>".}

Swap the contents of vectors v1 and v2.

https://en.cppreference.com/w/cpp/container/vector/swap

Example:

var
  v1 = @[1, 2, 3].toVector()
  v2 = @[7, 8, 9].toVector()
v1.swap(v2)
doAssert v1.toSeq() == @[7, 8, 9]
doAssert v2.toSeq() == @[1, 2, 3]

proc size(v: Vector): SizeType {.inline.}

Alias for len proc.

proc pushBack[T](v: var Vector[T]; elem: T) {.inline.}

Alias for add proc.

proc front[T](v: Vector[T]): T {.inline.}

Alias for first proc.

proc back[T](v: Vector[T]): T {.inline.}

Alias for last proc.

proc `[]=`[T](v: var Vector[T]; idx: SizeType; val: T) {.inline.}

Set the value at v[idx] to the specified value val.

Example:

var
  v = initVector[int](2)
doAssert v.toSeq() == @[0, 0]

v[0] = -1
doAssert v.toSeq() == @[-1, 0]

proc toSeq[T](v: Vector[T]): seq[T]

Convert a Vector to a sequence.

Example:

var
  v: Vector[char]
v.assign(3, 'k')

doAssert v.toSeq() == @['k', 'k', 'k']

proc toVector[T](s: openArray[T]): Vector[T]

Convert an array/sequence to a Vector.

Example:

let
  s = @[1, 2, 3]
  a = [1, 2, 3]

doAssert s.toVector().toSeq() == s
doAssert a.toVector().toSeq() == s

proc `$`[T](v: Vector[T]): string {.noinit.}

The $ operator for Vector type variables. This is used internally when calling echo on a Vector type variable.

Example:

var
  v = initVector[int]()
doAssert $v == "v[]"

v.add(100)
v.add(200)
doAssert $v == "v[100, 200]"

Iterators

iterator items[T](v: Vector[T]): T

Iterate over all the elements in Vector v.

Example:

var
  v: Vector[int]
  sum: int

v.assign(3, 5)

for elem in v:
  sum += elem
doAssert sum == 15

iterator pairs[T](v: Vector[T]): (SizeType, T)

Iterate over (index, value) for all the elements in Vector v.

Example:

var
  v: Vector[int]
  sum: int

v.assign(3, 5)

for idx, elem in v:
  sum += idx.int + elem
doAssert sum == 18

Converters

converter VectorIterToVectorConstIter[T](x: VectorIter[T]): VectorConstIter[T] {. importcpp: "#", header: "<vector>".}: Implicitly convert mutable C++ iterator to immutable C++ iterator.

src/std_vector

Introduction

Source

Types

Procs

Iterators

Converters