Index

Modules: cppstl, cppstl/private/iterators, 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: proc `!=`[T](a: CppBasicString[T]; b: CppBasicString[T]): bool
• std_basicstring: proc `!=`[T](a: CppBasicString[T]; b: ptr UncheckedArray[T]): bool
• std_basicstring: proc `!=`[T](a: ptr UncheckedArray[T]; b: CppBasicString[T]): bool
• std_complex: proc `!=`[T: SomeFloat](a, b: CppComplex[T]): bool
• std_pair: proc `!=`[T1, T2](lhs, rhs: CppPair[T1, T2]): bool
• std_string: proc `!=`(a: string | cstring; b: CppString): bool
• std_string: proc `!=`(a: CppString; b: string | cstring): bool
• std_string: proc `!=`(a: CppString; b: CppString): bool
• std_vector: proc `!=`[T](a: CppVector[T]; b: CppVector[T]): bool

`$`:

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

`*=`:

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

`*`:

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

`+=`:

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

`+`:

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

`-=`:

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

`-`:

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

`.()`:

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

`.=`:

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

`.`:

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

`/=`:

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

`/`:

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

`<=`:

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

`<`:

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

`==`:

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

`=copy`:

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

`=sink`:

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

`>=`:

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

`>`:

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

`[]=`:

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

`[]`:

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

`end`:

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

`iterator`:

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

abs:

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

add:

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

append:

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

arg:

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

assign:

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

at:

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

back:

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

begin:

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

capacity:

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

cBegin:

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

cEnd:

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

clear:

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

compare:

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

conj:

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

constIterator:

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

copy:

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

CppBasicString:

• std_basicstring: object CppBasicString

CppBasicStringConstIterator:

• std_basicstring: type CppBasicStringConstIterator

CppBasicStringIterator:

• std_basicstring: type CppBasicStringIterator

CppBasicStringIteratorToBasicStringConstIterator:

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

CppComplex:

• std_complex: object CppComplex

CppConstIterator:

• iterators: object CppConstIterator

CppIterator:

• iterators: object CppIterator

CppPair:

• std_pair: object CppPair

CppSharedPtr:

• std_smartptrs: object CppSharedPtr

CppStrConstIterator:

• std_string: type CppStrConstIterator

CppString:

• std_string: type CppString

CppStrIterator:

• std_string: type CppStrIterator

CppStrIteratorToStrConstIterator:

• std_string: converter CppStrIteratorToStrConstIterator(s: CppStrIterator): CppStrConstIterator

CppUniquePtr:

• std_smartptrs: object CppUniquePtr

CppVector:

• std_vector: object CppVector

CppVectorConstIterator:

• std_vector: type CppVectorConstIterator

CppVectorIterator:

• std_vector: type CppVectorIterator

CppVectorIteratorToCppVectorConstIterator:

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

crBegin:

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

crEnd:

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

cStr:

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

data:

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

deref:

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

empty:

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

erase:

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

find:

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

findFirstNotOf:

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

findFirstOf:

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

findLastNotOf:

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

findLastOf:

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

first:

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

first=:

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

front:

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

get:

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

imag:

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

inc:

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

initCppBasicString:

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

initCppComplex:

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

initCppPair:

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

initCppString:

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

initCppVector:

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

insert:

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

items:

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

last:

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

len:

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

length:

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

makePair:

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

makeShared:

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

makeUnique:

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

maxSize:

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

mitems:

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

mpairs:

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

newCppSharedPtr:

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

norm:

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

OutOfRangeException:

• std_exception: object OutOfRangeException

pairs:

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

polar:

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

popBack:

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

pushBack:

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

rBegin:

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

real:

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

rEnd:

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

replace:

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

reserve:

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

resize:

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

rfind:

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

second:

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

second=:

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

shrinkToFit:

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

size:

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

stdNpos:

• std_basicstring: const stdNpos

substr:

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

swap:

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

toComplex:

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

toCppComplex:

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

toCppString:

• std_string: proc toCppString(s: string): CppString

toCppVector:

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

toSeq:

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

toString:

• std_string: proc toString(s: CppString): string

toTuple:

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