Index

Modules: cppstl/private/iterators, cppstl/private/utils, cppstl/std_basicstring, cppstl/std_complex, cppstl/std_exception, cppstl/std_pair, cppstl/std_smartptrs, cppstl/std_string, cppstl/std_vector.

API symbols

`!=`:

• std_basicstring: `!=`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: `!=`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: `!=`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_complex: `!=`[T: SomeFloat](a, b: CppComplex[T]): bool
• std_pair: `!=`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: `!=`(a: string | cstring; b: CppString): bool
• std_string: `!=`(a: CppString; b: string | cstring): bool
• std_vector: `!=`[T](a: CppVector[T]; b: CppVector[T]): bool

`$`:

• std_complex: `$`[T](c: CppComplex[T]): string
• std_pair: `$`[F, S](val: CppPair[F, S]): string
• std_smartptrs: `$`[T](p: CppSharedPtr[T]): string
• std_smartptrs: `$`[T](p: CppUniquePtr[T]): string
• std_string: `$`(s: CppString): string
• std_vector: `$`[T](v: CppVector[T]): string

`>=`:

• std_basicstring: `>=`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: `>=`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: `>=`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_pair: `>=`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: `>=`(a: string | cstring; b: CppString): bool
• std_string: `>=`(a: CppString; b: string | cstring): bool
• std_vector: `>=`[T](a: CppVector[T]; b: CppVector[T]): bool

`>`:

• std_basicstring: `>`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: `>`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: `>`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_pair: `>`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: `>`(a: string | cstring; b: CppString): bool
• std_string: `>`(a: CppString; b: string | cstring): bool
• std_vector: `>`[T](a: CppVector[T]; b: CppVector[T]): bool

`<=`:

• std_basicstring: `<=`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: `<=`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: `<=`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_pair: `<=`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: `<=`(a: string | cstring; b: CppString): bool
• std_string: `<=`(a: CppString; b: string | cstring): bool
• std_vector: `<=`[T](a: CppVector[T]; b: CppVector[T]): bool

`<`:

• std_basicstring: `<`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: `<`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: `<`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_pair: `<`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: `<`(a: string | cstring; b: CppString): bool
• std_string: `<`(a: CppString; b: string | cstring): bool
• std_vector: `<`[T](a: CppVector[T]; b: CppVector[T]): bool

`*=`:

• std_complex: `*=`[T: SomeFloat](self: var CppComplex[T]; arg: CppComplex[T])

`*`:

• std_complex: `*`[T: SomeFloat](a, b: CppComplex[T]): CppComplex[T]

`+=`:

• std_basicstring: `+=`[T](self: var CppBasicString[T]; str: CppBasicString[T])
• std_basicstring: `+=`[T](self: var CppBasicString[T]; str: ptr UncheckedArray[T])
• std_basicstring: `+=`[T](self: var CppBasicString[T]; str: T)
• std_complex: `+=`[T: SomeFloat](self: var CppComplex[T]; arg: CppComplex[T])
• std_string: `+=`(self: var CppString; str: cstring)

`+`:

• iterators: `+`[I: SomeCppIterator](it: I; offset: int): I
• std_basicstring: `+`[T](a: CppBasicString[T]; b: CppBasicString[T]): CppBasicString[T]
• std_basicstring: `+`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): CppBasicString[T]
• std_basicstring: `+`[T](a: CppBasicString[T]; b: T): CppBasicString[T]
• std_basicstring: `+`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): CppBasicString[T]
• std_basicstring: `+`[T](a: T; b: CppBasicString[T]): CppBasicString[T]
• std_complex: `+`[T: SomeFloat](a, b: CppComplex[T]): CppComplex[T]
• std_string: `+`(a: string | cstring; b: CppString): CppString
• std_string: `+`(a: CppString; b: string | cstring): CppString

`-=`:

• std_complex: `-=`[T: SomeFloat](self: var CppComplex[T]; arg: CppComplex[T])

`-`:

• iterators: `-`[I: SomeCppIterator](it: I; offset: int): I
• std_complex: `-`[T: SomeFloat](a, b: CppComplex[T]): CppComplex[T]

`.()`:

• std_smartptrs: `.()`[T](p: CppUniquePtr[T] or CppSharedPtr[T]; fieldOrFunc: untyped; args: varargs[untyped]): untyped

`.=`:

• std_smartptrs: `.=`[T](p: CppUniquePtr[T] or CppSharedPtr[T]; fieldOrFunc: untyped; args: untyped): untyped

`.`:

• std_smartptrs: `.`[T](p: CppUniquePtr[T] or CppSharedPtr[T]; fieldOrFunc: untyped): untyped

`/=`:

• std_complex: `/=`[T: SomeFloat](self: var CppComplex[T]; arg: CppComplex[T])

`/`:

• std_complex: `/`[T: SomeFloat](a, b: CppComplex[T]): CppComplex[T]

`==`:

• iterators: `==`[ValueType](it, otherIt: CppConstIterator[ValueType]): bool
• iterators: `==`[ValueType](it, otherIt: CppIterator[ValueType]): bool
• std_basicstring: `==`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: `==`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: `==`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_complex: `==`[T: SomeFloat](a, b: CppComplex[T]): bool
• std_pair: `==`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: `==`(a: string | cstring; b: CppString): bool
• std_string: `==`(a: CppString; b: string | cstring): bool
• std_vector: `==`[T](a: CppVector[T]; b: CppVector[T]): bool

`=copy`:

• std_smartptrs: `=copy`[T](p: var CppSharedPtr[T]; o: CppSharedPtr[T])
• std_smartptrs: `=copy`[T](dst: var CppUniquePtr[T]; src: CppUniquePtr[T])

`=sink`:

• std_smartptrs: `=sink`[T](dst: var CppSharedPtr[T]; src: CppSharedPtr[T])
• std_smartptrs: `=sink`[T](dst: var CppUniquePtr[T]; src: CppUniquePtr[T])

`[]=`:

• std_basicstring: `[]=`[T](self: var CppBasicString[T]; idx: Natural; val: T)
• std_vector: `[]=`[T](self: var CppVector[T]; idx: Natural; val: T)

`[]`:

• iterators: `[]`[ValueType](it: CppConstIterator[ValueType]): ValueType
• iterators: `[]`[ValueType](it: CppIterator[ValueType]): var ValueType
• std_basicstring: `[]`[T](self: CppBasicString[T]; idx: Natural): T
• std_basicstring: `[]`[T](self: var CppBasicString[T]; idx: Natural): var T
• std_vector: `[]`[T](self: CppVector[T]; idx: Natural): lent T
• std_vector: `[]`[T](self: var CppVector[T]; idx: Natural): var T

`end`:

• std_basicstring: `end`[T](x: CppBasicString[T]): CppBasicStringIterator[T]
• std_vector: `end`[T](v: CppVector[T]): CppVectorIterator[T]

`iterator`:

• std_vector: `iterator`[T](_: typedesc[CppVector[T]]): typedesc[CppVectorIterator[T]]

abs:

• std_complex: abs[T: SomeFloat](self: CppComplex[T]): T

add:

• std_basicstring: add[T](v: var CppBasicString[T]; elem: T)
• std_vector: add[T](v: var CppVector[T]; elem: T)

append:

• std_basicstring: append[T](self: var CppBasicString[T]; str: CppBasicString[T])
• std_basicstring: append[T](self: var CppBasicString[T]; str: CppBasicString[T]; subpos, sublen: csize_t)
• std_basicstring: append[T](self: var CppBasicString[T]; first, last: CppBasicStringConstIterator[T])
• std_basicstring: append[T](self: var CppBasicString[T]; n: csize_t; str: T)
• std_basicstring: append[T](self: var CppBasicString[T]; str: ptr UncheckedArray[T])
• std_basicstring: append[T](self: var CppBasicString[T]; str: ptr UncheckedArray[T]; n: csize_t)
• std_string: append(self: var CppString; str: cstring)
• std_string: append(self: var CppString; str: cstring; n: csize_t)

arg:

• std_complex: arg[T: SomeFloat](self: CppComplex[T]): T

assign:

• std_basicstring: assign[T](self: var CppBasicString[T]; str: CppBasicString[T])
• std_basicstring: assign[T](self: var CppBasicString[T]; str: CppBasicString[T]; subpos, sublen: csize_t)
• std_basicstring: assign[T](self: var CppBasicString[T]; first, last: CppBasicStringConstIterator[T])
• std_basicstring: assign[T](self: var CppBasicString[T]; n: csize_t; c: T)
• std_basicstring: assign[T](self: var CppBasicString[T]; str: ptr UncheckedArray[T])
• std_basicstring: assign[T](self: var CppBasicString[T]; str: ptr UncheckedArray[T]; n: csize_t)
• std_string: assign(self: var CppString; str: cstring)
• std_string: assign(self: var CppString; str: cstring; n: csize_t)
• std_vector: assign[T](v: var CppVector[T]; num: csize_t; val: T)
• std_vector: assign[T](first: CppVectorIterator[T]; last: CppVectorIterator[T])
• std_vector: assign[T](n: csize_t; val: T)

at:

• std_basicstring: at[T](self: var CppBasicString[T]; n: csize_t): var T
• std_basicstring: at[T](self: CppBasicString[T]; n: csize_t): T
• std_vector: at[T](self: var CppVector[T]; n: csize_t): var T
• std_vector: at[T](self: CppVector[T]; n: csize_t): T

back:

• std_basicstring: back[T](self: CppBasicString[T]): T
• std_basicstring: back[T](self: var CppBasicString[T]): var T
• std_vector: back[T](v: var CppVector[T]): var T
• std_vector: back[T](v: CppVector[T]): T

begin:

• std_basicstring: begin[T](x: CppBasicString[T]): CppBasicStringIterator[T]
• std_vector: begin[T](v: CppVector[T]): CppVectorIterator[T]

capacity:

• std_basicstring: capacity[T](self: CppBasicString[T]): csize_t
• std_vector: capacity[T](self: CppVector[T]): csize_t

cBegin:

• std_basicstring: cBegin[T](x: CppBasicString[T]): CppBasicStringConstIterator[T]
• std_vector: cBegin[T](v: CppVector[T]): CppVectorConstIterator[T]

cEnd:

• std_basicstring: cEnd[T](x: CppBasicString[T]): CppBasicStringConstIterator[T]
• std_vector: cEnd[T](v: CppVector[T]): CppVectorConstIterator[T]

clear:

• std_basicstring: clear[T](self: var CppBasicString[T])
• std_vector: clear[T](self: var CppVector[T])

compare:

• std_basicstring: compare[T](self, str: CppBasicString[T]): cint
• std_basicstring: compare[T](self: CppBasicString[T]; pos, l: csize_t; str: CppBasicString[T]): cint
• std_basicstring: compare[T](self: CppBasicString[T]; pos, l: csize_t; str: CppBasicString[T]; subpos, subl: csize_t): cint
• std_basicstring: compare[T](self: CppBasicString[T]; pos, l: csize_t; str: ptr UncheckedArray[T]): cint
• std_basicstring: compare[T](self: CppBasicString[T]; pos, l: csize_t; str: ptr UncheckedArray[T]; n: csize_t): cint
• std_basicstring: compare[T](self: CppBasicString[T]; pos, l: csize_t; str: ptr UncheckedArray[T]; subpos, subl: csize_t): cint
• std_basicstring: compare[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]): cint
• std_string: compare(self: CppString; pos, l: csize_t; str: cstring): cint
• std_string: compare(self: CppString; pos, l: csize_t; str: cstring; n: csize_t): cint
• std_string: compare(self: CppString; pos, l: csize_t; str: cstring; subpos, subl: csize_t): cint
• std_string: compare(self: CppString; s: cstring): cint

conj:

• std_complex: conj[T: SomeFloat](self: CppComplex[T]): CppComplex[T]

constIterator:

• std_vector: constIterator[T](_: typedesc[CppVector[T]]): typedesc[CppVectorConstIterator[T]]

copy:

• std_basicstring: copy[T](self: CppBasicString[T]; s: ptr T; l: csize_t; pos: csize_t = 0): csize_t

CppBasicString:

• std_basicstring: CppBasicString

CppBasicStringConstIterator:

• std_basicstring: CppBasicStringConstIterator

CppBasicStringIterator:

• std_basicstring: CppBasicStringIterator

CppBasicStringIteratorToBasicStringConstIterator:

• std_basicstring: CppBasicStringIteratorToBasicStringConstIterator[T](s: CppBasicStringIterator[T]): CppBasicStringConstIterator[ T]

CppComplex:

• std_complex: CppComplex

CppConstIterator:

• iterators: CppConstIterator

CppIterator:

• iterators: CppIterator

CppPair:

• std_pair: CppPair

CppSharedPtr:

• std_smartptrs: CppSharedPtr

CppStrConstIterator:

• std_string: CppStrConstIterator

CppString:

• std_string: CppString

CppStrIterator:

• std_string: CppStrIterator

CppStrIteratorToStrConstIterator:

• std_string: CppStrIteratorToStrConstIterator(s: CppStrIterator): CppStrConstIterator

CppUniquePtr:

• std_smartptrs: CppUniquePtr

CppVector:

• std_vector: CppVector

CppVectorConstIterator:

• std_vector: CppVectorConstIterator

CppVectorIterator:

• std_vector: CppVectorIterator

CppVectorIteratorToCppVectorConstIterator:

• std_vector: CppVectorIteratorToCppVectorConstIterator[T](x: CppVectorIterator[T]): CppVectorConstIterator[ T]

crBegin:

• std_basicstring: crBegin[T](x: CppBasicString[T]): CppBasicStringConstIterator[T]
• std_vector: crBegin[T](x: CppVector[T]): CppVectorConstIterator[T]

crEnd:

• std_basicstring: crEnd[T](x: CppBasicString[T]): CppBasicStringConstIterator[T]
• std_vector: crEnd[T](x: CppVector[T]): CppVectorConstIterator[T]

cStr:

• std_basicstring: cStr[T](self: CppBasicString[T]): ptr UncheckedArray[T]
• std_string: cStr(self: CppString): cstring

data:

• std_basicstring: data[T](self: CppBasicString[T]): ptr T
• std_vector: data[T](self: CppVector[T]): ptr T

deref:

• std_smartptrs: deref[T](p: CppUniquePtr[T] or CppSharedPtr[T]): var T

empty:

• std_basicstring: empty[T](self: CppBasicString[T]): bool
• std_vector: empty(v: CppVector): bool

erase:

• std_basicstring: erase[T](self: var CppBasicString[T])
• std_basicstring: erase[T](self: var CppBasicString[T]; pos: CppBasicStringIterator[T])
• std_basicstring: erase[T](self: var CppBasicString[T]; first, last: CppBasicStringIterator[T])
• std_basicstring: erase[T](self: var CppBasicString[T]; pos: csize_t; l: csize_t = std_npos)
• std_vector: erase[T](self: var CppVector[T]; position: CppVectorConstIterator[T]): CppVectorIterator[ T]
• std_vector: erase[T](self: var CppVector[T]; first, last: CppVectorConstIterator[T]): CppVectorIterator[ T]

find:

• std_basicstring: find[T](self, str: CppBasicString[T]; pos: csize_t = 0): csize_t
• std_basicstring: find[T](self, str: CppBasicString[T]; pos, n: csize_t): csize_t
• std_basicstring: find[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos: csize_t = 0): csize_t
• std_basicstring: find[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos, n: csize_t): csize_t
• std_basicstring: find[T](self: CppBasicString[T]; c: T; pos: csize_t = 0): csize_t
• std_string: find(self: CppString; s: cstring; pos: csize_t = 0): csize_t
• std_string: find(self: CppString; s: cstring; pos, n: csize_t): csize_t

findFirstNotOf:

• std_basicstring: findFirstNotOf[T](self, str: CppBasicString[T]; pos: csize_t = 0): csize_t
• std_basicstring: findFirstNotOf[T](self, str: CppBasicString[T]; pos, n: csize_t): csize_t
• std_basicstring: findFirstNotOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos: csize_t = 0): csize_t
• std_basicstring: findFirstNotOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos, n: csize_t): csize_t
• std_basicstring: findFirstNotOf[T](self: CppBasicString[T]; c: T; pos: csize_t = 0): csize_t
• std_string: findFirstNotOf(self: CppString; s: cstring; pos: csize_t = 0): csize_t
• std_string: findFirstNotOf(self: CppString; s: cstring; pos, n: csize_t): csize_t

findFirstOf:

• std_basicstring: findFirstOf[T](self, str: CppBasicString[T]; pos: csize_t = 0): csize_t
• std_basicstring: findFirstOf[T](self, str: CppBasicString[T]; pos, n: csize_t): csize_t
• std_basicstring: findFirstOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos: csize_t = 0): csize_t
• std_basicstring: findFirstOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos, n: csize_t): csize_t
• std_basicstring: findFirstOf[T](self: CppBasicString[T]; c: T; pos: csize_t = 0): csize_t
• std_string: findFirstOf(self: CppString; s: cstring; pos: csize_t = 0): csize_t
• std_string: findFirstOf(self: CppString; s: cstring; pos, n: csize_t): csize_t

findLastNotOf:

• std_basicstring: findLastNotOf[T](self, str: CppBasicString[T]; pos: csize_t = std_npos): csize_t
• std_basicstring: findLastNotOf[T](self, str: CppBasicString[T]; pos, n: csize_t): csize_t
• std_basicstring: findLastNotOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos: csize_t = std_npos): csize_t
• std_basicstring: findLastNotOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos, n: csize_t): csize_t
• std_basicstring: findLastNotOf[T](self: CppBasicString[T]; c: T; pos: csize_t = std_npos): csize_t
• std_string: findLastNotOf(self: CppString; s: cstring; pos: csize_t = std_npos): csize_t
• std_string: findLastNotOf(self: CppString; s: cstring; pos, n: csize_t): csize_t

findLastOf:

• std_basicstring: findLastOf[T](self, str: CppBasicString[T]; pos: csize_t = std_npos): csize_t
• std_basicstring: findLastOf[T](self: CppBasicString[T]; s: CppBasicString[T]; pos, n: csize_t): csize_t
• std_basicstring: findLastOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos: csize_t = std_npos): csize_t
• std_basicstring: findLastOf[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos, n: csize_t): csize_t
• std_basicstring: findLastOf[T](self: CppBasicString[T]; c: T; pos: csize_t = std_npos): csize_t
• std_string: findLastOf(self: CppString; s: cstring; pos: csize_t = std_npos): csize_t
• std_string: findLastOf(self: CppString; s: cstring; pos, n: csize_t): csize_t

first:

• std_basicstring: first[T](v: var CppBasicString[T]): var T
• std_basicstring: first[T](v: CppBasicString[T]): T
• std_pair: first[T1, T2](this: CppPair[T1, T2]): T1
• std_pair: first[T1, T2](this: var CppPair[T1, T2]): var T1
• std_vector: first[T](v: var CppVector[T]): var T
• std_vector: first[T](v: CppVector[T]): T

first=:

• std_pair: first=[T1, T2](this: var CppPair[T1, T2]; val: T1)

front:

• std_basicstring: front[T](self: CppBasicString[T]): T
• std_basicstring: front[T](self: var CppBasicString[T]): var T
• std_vector: front[T](v: var CppVector[T]): var T
• std_vector: front[T](v: CppVector[T]): T

get:

• std_pair: get[T1, T2](n: static int; p: CppPair[T1, T2]): auto
• std_pair: get[T1, T2](T: typedesc; p: CppPair[T1, T2]): auto
• std_smartptrs: get[T](p: CppUniquePtr[T] or CppSharedPtr[T]): ptr T

imag:

• std_complex: imag[T: SomeFloat](self: CppComplex[T]): T

inc:

• iterators: inc(it: SomeCppIterator)
• iterators: inc(it: SomeCppIterator; offset: int)

initCppBasicString:

• std_basicstring: initCppBasicString[T](): CppBasicString[T]
• std_basicstring: initCppBasicString[T](str: CppBasicString[T]): CppBasicString[T]
• std_basicstring: initCppBasicString[T](str: CppBasicString[T]; pos: csize_t): CppBasicString[T]
• std_basicstring: initCppBasicString[T](str: CppBasicString[T]; pos, len: csize_t): CppBasicString[ T]
• std_basicstring: initCppBasicString[T](first, last: CppBasicStringConstIterator): CppBasicString[ T]
• std_basicstring: initCppBasicString[T](s: ptr UncheckedArray[T]): CppBasicString[T]
• std_basicstring: initCppBasicString[T](s: ptr UncheckedArray[T]; n: csize_t): CppBasicString[T]

initCppComplex:

• std_complex: initCppComplex[T: SomeFloat](re, im: T): CppComplex[T]

initCppPair:

• std_pair: initCppPair[T1, T2](): CppPair[T1, T2]
• std_pair: initCppPair[T1, T2](p: CppPair[T1, T2]): CppPair[T1, T2]
• std_pair: initCppPair[T1, T2](x: T1; y: T2): CppPair[T1, T2]

initCppString:

• std_string: initCppString(): CppString
• std_string: initCppString(first, last: CppStrConstIterator): CppString
• std_string: initCppString(str: CppString): CppString
• std_string: initCppString(str: CppString; pos: csize_t): CppString
• std_string: initCppString(str: CppString; pos, len: csize_t): CppString
• std_string: initCppString(s: cstring): CppString
• std_string: initCppString(s: cstring; n: csize_t): CppString
• std_string: initCppString(s: string): CppString

initCppVector:

• std_vector: initCppVector[T](): CppVector[T]
• std_vector: initCppVector[T](x: CppVector[T]): CppVector[T]
• std_vector: initCppVector[T](first, last: CppVectorConstIterator[T]): CppVector[T]
• std_vector: initCppVector[T](n: csize_t): CppVector[T]
• std_vector: initCppVector[T](n: csize_t; val: T): CppVector[T]

insert:

• std_basicstring: insert[T](self: var CppBasicString[T]; p: CppBasicStringConstIterator[T]; n: csize_t; c: T)
• std_basicstring: insert[T](self: var CppBasicString[T]; p: CppBasicStringConstIterator[T]; c: T)
• std_basicstring: insert[T](self: var CppBasicString[T]; p: CppBasicStringIterator[T]; first, last: CppBasicStringConstIterator[T])
• std_basicstring: insert[T](self: var CppBasicString[T]; pos: csize_t; str: CppBasicString[T])
• std_basicstring: insert[T](self: var CppBasicString[T]; pos: csize_t; str: CppBasicString[T]; subpos, sublen: csize_t)
• std_basicstring: insert[T](self: var CppBasicString[T]; p, n: csize_t; c: T)
• std_basicstring: insert[T](self: var CppBasicString[T]; pos: csize_t; s: ptr UncheckedArray[T])
• std_basicstring: insert[T](self: var CppBasicString[T]; pos: csize_t; s: ptr UncheckedArray[T]; n: csize_t)
• std_string: insert(self: var CppString; pos: csize_t; s: cstring)
• std_string: insert(self: var CppString; pos: csize_t; s: cstring; n: csize_t)
• std_vector: insert[T](v: var CppVector[T]; position, first, last: CppVectorConstIterator[T]): CppVectorIterator[ T]
• std_vector: insert[T](v: var CppVector[T]; position: CppVectorConstIterator[T]; count: csize_t; val: T): CppVectorIterator[T]
• std_vector: insert[T](v: var CppVector[T]; position: CppVectorConstIterator[T]; val: T): CppVectorIterator[ T]

items:

• std_basicstring: items[T](v: CppBasicString[T]): T
• std_vector: items[T](v: CppVector[T]): T

iteratorsArithmetics:

• utils: iteratorsArithmetics(name: untyped): untyped

last:

• std_basicstring: last[T](v: var CppBasicString[T]): var T
• std_basicstring: last[T](v: CppBasicString[T]): T
• std_vector: last[T](v: var CppVector[T]): var T
• std_vector: last[T](v: CppVector[T]): T

len:

• std_basicstring: len[T](v: CppBasicString[T]): csize_t
• std_vector: len(v: CppVector): csize_t

length:

• std_basicstring: length[T](s: CppBasicString[T]): csize_t

makePair:

• std_pair: makePair[F, S](a: F; b: S): CppPair[F, S]
• std_pair: makePair[F, S](t: tuple[first: F, second: S]): CppPair[F, S]

makeShared:

• std_smartptrs: makeShared[T](p: CppSharedPtr[T]): CppSharedPtr[T]
• std_smartptrs: makeShared(T: typedesc): CppSharedPtr[T]

makeUnique:

• std_smartptrs: makeUnique(T: typedesc): CppUniquePtr[T]

maxSize:

• std_basicstring: maxSize[T](self: CppBasicString[T]): csize_t
• std_vector: maxSize[T](self: CppVector[T]): csize_t

mitems:

• std_basicstring: mitems[T](v: var CppBasicString[T]): var T

mpairs:

• std_basicstring: mpairs[T](v: var CppBasicString[T]): (csize_t, var T)

newCppSharedPtr:

• std_smartptrs: newCppSharedPtr[T](p: ptr T): CppSharedPtr[T]

norm:

• std_complex: norm[T: SomeFloat](self: CppComplex[T]): T

OutOfRangeException:

• std_exception: OutOfRangeException

pairs:

• std_basicstring: pairs[T](v: CppBasicString[T]): (csize_t, T)
• std_vector: pairs[T](v: CppVector[T]): (csize_t, T)

polar:

• std_complex: polar[T: SomeFloat](r, theta: T): CppComplex[T]

popBack:

• std_basicstring: popBack[T](self: var CppBasicString[T])
• std_vector: popBack[T](v: var CppVector[T])

pushBack:

• std_basicstring: pushBack[T](self: var CppBasicString[T]; x: T)
• std_vector: pushBack[T](v: var CppVector[T]; elem: T)

rBegin:

• std_basicstring: rBegin[T](x: CppBasicString[T]): CppBasicStringIterator[T]
• std_vector: rBegin[T](x: CppVector[T]): CppVectorIterator[T]

real:

• std_complex: real[T: SomeFloat](self: CppComplex[T]): T

rEnd:

• std_basicstring: rEnd[T](x: CppBasicString[T]): CppBasicStringIterator[T]
• std_vector: rEnd[T](x: CppVector[T]): CppVectorIterator[T]

replace:

• std_basicstring: replace[T](self: var CppBasicString[T]; i1, i2: CppBasicStringConstIterator[T]; str: CppBasicString[T])
• std_basicstring: replace[T](self: var CppBasicString[T]; i1, i2: CppBasicStringConstIterator[T]; first, last: CppBasicStringConstIterator[T])
• std_basicstring: replace[T](self: var CppBasicString[T]; i1, i2: CppBasicStringConstIterator[T]; n: csize_t; c: T)
• std_basicstring: replace[T](self: var CppBasicString[T]; i1, i2: CppBasicStringConstIterator[T]; s: ptr UncheckedArray[T])
• std_basicstring: replace[T](self: var CppBasicString[T]; i1, i2: CppBasicStringConstIterator[T]; s: ptr UncheckedArray[T]; n: csize_t)
• std_basicstring: replace[T](self: var CppBasicString[T]; pos, l: csize_t; str: CppBasicString[T])
• std_basicstring: replace[T](self: var CppBasicString[T]; pos, l: csize_t; str: CppBasicString[T]; subpos, subl: csize_t)
• std_basicstring: replace[T](self: var CppBasicString[T]; pos, l: csize_t; n: csize_t; c: T)
• std_basicstring: replace[T](self: var CppBasicString[T]; pos, l: csize_t; s: ptr UncheckedArray[T])
• std_basicstring: replace[T](self: var CppBasicString[T]; pos, l: csize_t; s: ptr UncheckedArray[T]; n: csize_t)
• std_string: replace(self: var CppString; i1, i2: CppStrConstIterator; s: cstring)
• std_string: replace(self: var CppString; i1, i2: CppStrConstIterator; s: cstring; n: csize_t)
• std_string: replace(self: var CppString; pos, l: csize_t; s: cstring)
• std_string: replace(self: var CppString; pos, l: csize_t; s: cstring; n: csize_t)

reserve:

• std_basicstring: reserve[T](self: var CppBasicString[T]; n: csize_t)
• std_vector: reserve[T](self: var CppVector[T]; n: csize_t)

resize:

• std_basicstring: resize[T](self: CppBasicString[T]; n: csize_t)
• std_vector: resize[T](self: CppVector[T]; n: csize_t)

rfind:

• std_basicstring: rfind[T](self, str: CppBasicString[T]; pos: csize_t = std_npos): csize_t
• std_basicstring: rfind[T](self: CppBasicString[T]; s: CppBasicString[T]; pos, n: csize_t): csize_t
• std_basicstring: rfind[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos: csize_t = std_npos): csize_t
• std_basicstring: rfind[T](self: CppBasicString[T]; s: ptr UncheckedArray[T]; pos, n: csize_t): csize_t
• std_basicstring: rfind[T](self: CppBasicString[T]; c: T; pos: csize_t = std_npos): csize_t
• std_string: rfind(self: CppString; s: cstring; pos: csize_t = std_npos): csize_t
• std_string: rfind(self: CppString; s: cstring; pos, n: csize_t): csize_t

second:

• std_pair: second[T1, T2](this: CppPair[T1, T2]): T2
• std_pair: second[T1, T2](this: var CppPair[T1, T2]): var T2

second=:

• std_pair: second=[T1, T2](this: var CppPair[T1, T2]; val: T2)

shrinkToFit:

• std_basicstring: shrinkToFit[T](self: var CppBasicString[T])
• std_vector: shrinkToFit[T](self: var CppVector[T])

size:

• std_basicstring: size[T](self: CppBasicString[T]): csize_t
• std_vector: size(v: CppVector): csize_t

stdNpos:

• std_basicstring: stdNpos

substr:

• std_basicstring: substr[T](self: CppBasicString[T]; pos: csize_t = 0; l: csize_t = std_npos): CppBasicString[ T]

swap:

• std_basicstring: swap[T](self: var CppBasicString[T]; x: var CppBasicString[T])
• std_pair: swap[T1, T2](this, other: var CppPair[T1, T2])
• std_vector: swap[T](v1, v2: var CppVector[T])

toComplex:

• std_complex: toComplex[T](c: CppComplex[T]): Complex[T]

toCppComplex:

• std_complex: toCppComplex[T](c: Complex[T]): CppComplex[T]

toCppString:

• std_string: toCppString(s: string): CppString

toCppVector:

• std_vector: toCppVector[T](s: openArray[T]): CppVector[T]

toSeq:

• std_vector: toSeq[T](v: CppVector[T]): seq[T]

toString:

• std_string: toString(s: CppString): string

toTuple:

• std_pair: toTuple[F, S](val: CppPair[F, S]): tuple[first: F, second: S]