gdext/dicttools

Search:
Group by:

Procs

func `==`(left: Dictionary[Variant, Variant];
          right: Dictionary[Variant, Variant]): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
func `==`[A, B](left, right: Dictionary[A, B]): bool
proc `[]`(self: Dictionary[Variant, Variant]; key: Variant): Variant {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc `[]`(self: var Dictionary[Variant, Variant]; key: Variant): var Variant {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc `[]`[A, B: not Variant](self: Dictionary[A, B]; key: A): B
proc `[]`[A: not Variant; B: SomeBuiltins](self: var Dictionary[A, B]; key: A): var B
proc `[]`[A: not Variant](self: var Dictionary[A, Variant]; key: A): var Variant
proc `[]`[B: not Variant](self: Dictionary[Variant, B]; key: Variant): B
proc `[]`[B: SomeBuiltins](self: var Dictionary[Variant, B]; key: Variant): var B
proc `[]=`(self: var Dictionary[Variant, Variant]; key: Variant;
           value: sink Variant) {....raises: [Exception], tags: [RootEffect],
                                  forbids: [].}
proc `[]=`[A, B: not Variant](self: var Dictionary[A, B]; key: A; value: sink B)
proc `[]=`[A, B; C, D](self: var Dictionary[A, B]; key: C; value: sink D)
proc `[]=`[A: not Variant](self: var Dictionary[A, Variant]; key: A;
                           value: sink Variant)
proc `[]=`[B: not Variant](self: var Dictionary[Variant, B]; key: Variant;
                           value: sink B)
proc assign(self: var Dictionary[Variant, Variant];
            dictionary: Dictionary[Variant, Variant]): void {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc assign[A, B](self: var Dictionary[A, B]; dictionary: Dictionary[A, B]): void
proc clear(self: var Dictionary[Variant, Variant]): void {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc clear[A, B](self: var Dictionary[A, B]): void
proc duplicate(self: Dictionary[Variant, Variant]; deep: bool = false): Dictionary[
    Variant, Variant] {....raises: [Exception], tags: [RootEffect], forbids: [].}
proc duplicate[A, B](self: Dictionary[A, B]; deep: bool = false): Dictionary[A,
    B]
proc duplicateDeep(self: Dictionary[Variant, Variant];
                   deepSubresourcesMode: Int = 1): Dictionary[Variant, Variant] {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc duplicateDeep[A, B](self: Dictionary[A, B]; deepSubresourcesMode: Int = 1): Dictionary[
    A, B]
proc erase(self: var Dictionary[Variant, Variant]; key: Variant): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc erase[A, B; C](self: var Dictionary[A, B]; key: C): bool
proc findKey(self: Dictionary[Variant, Variant]; value: Variant): Variant {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc findKey[A, B; C](self: Dictionary[A, B]; value: C): Variant
proc get(self: Dictionary[Variant, Variant]; key: Variant;
         default: Variant = default(Variant)): Variant {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc get[A, B; C](self: Dictionary[A, B]; key: C; default: B = default(B)): B
proc get[A: not Variant; B; C: not A](self: Dictionary[A, B]; key: C;
                                      default: B = default(B)): B {.error.}
proc get[A: not Variant; B](self: Dictionary[A, B]; key: Variant;
                            default: B = default(B)): B {.error.}
proc getOrAdd(self: var Dictionary[Variant, Variant]; key: Variant;
              default: Variant = default(Variant)): Variant {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getOrAdd[A, B; C](self: Dictionary[A, B]; key: C; default: B = default(B)): B
proc getOrAdd[A: not Variant; B; C: not A](self: Dictionary[A, B]; key: C;
    default: B = default(B)): B {.error.}
proc getTypedKeyBuiltin(self: Dictionary[Variant, Variant]): Int {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getTypedKeyBuiltin[A, B](self: Dictionary[A, B]): Int
proc getTypedKeyClassName(self: Dictionary[Variant, Variant]): StringName {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getTypedKeyClassName[A, B](self: Dictionary[A, B]): StringName
proc getTypedKeyScript(self: Dictionary[Variant, Variant]): Variant {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getTypedKeyScript[A, B](self: Dictionary[A, B]): Variant
proc getTypedValueBuiltin(self: Dictionary[Variant, Variant]): Int {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getTypedValueBuiltin[A, B](self: Dictionary[A, B]): Int
proc getTypedValueClassName(self: Dictionary[Variant, Variant]): StringName {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getTypedValueClassName[A, B](self: Dictionary[A, B]): StringName
proc getTypedValueScript(self: Dictionary[Variant, Variant]): Variant {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc getTypedValueScript[A, B](self: Dictionary[A, B]): Variant
proc has(self: Dictionary[Variant, Variant]; key: Variant): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc has[A, B; C](self: Dictionary[A, B]; key: C): bool
proc hasAll(self: Dictionary[Variant, Variant]; keys: Array[Variant]): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc hash(self: Dictionary[Variant, Variant]): Hash {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc isEmpty(self: Dictionary[Variant, Variant]): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc isEmpty[A, B](self: Dictionary[A, B]): bool
proc isReadOnly(self: Dictionary[Variant, Variant]): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc isReadOnly[A, B](self: Dictionary[A, B]): bool
proc isSameTyped(self: Dictionary[Variant, Variant];
                 dictionary: Dictionary[Variant, Variant]): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc isSameTyped[A, B, C, D](self: Dictionary[A, B];
                             dictionary: Dictionary[C, D]): bool
proc isSameTypedKey(self: Dictionary[Variant, Variant];
                    dictionary: Dictionary[Variant, Variant]): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc isSameTypedKey[A, B, C, D](self: Dictionary[A, B];
                                dictionary: Dictionary[C, D]): bool
proc isSameTypedValue(self: Dictionary[Variant, Variant];
                      dictionary: Dictionary[Variant, Variant]): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc isSameTypedValue[A, B, C, D](self: Dictionary[A, B];
                                  dictionary: Dictionary[C, D]): bool
proc isTyped(self: Dictionary[Variant, Variant]): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc isTyped[A, B](self: Dictionary[A, B]): bool
proc isTypedKey(self: Dictionary[Variant, Variant]): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc isTypedKey[A, B](self: Dictionary[A, B]): bool
proc isTypedValue(self: Dictionary[Variant, Variant]): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc isTypedValue[A, B](self: Dictionary[A, B]): bool
proc keys(self: Dictionary[Variant, Variant]): Array[Variant] {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc keys[A, B](self: Dictionary[A, B]): Array[A]
proc makeReadOnly(self: var Dictionary[Variant, Variant]): void {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc makeReadOnly[A, B](self: var Dictionary[A, B]): void
proc merge(self: var Dictionary[Variant, Variant];
           dictionary: Dictionary[Variant, Variant]; overwrite: bool = false): void {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc merge[A, B](self: var Dictionary[A, B]; dictionary: Dictionary[A, B]): void
proc merged(self: Dictionary[Variant, Variant];
            dictionary: Dictionary[Variant, Variant]; overwrite: bool = false): Dictionary[
    Variant, Variant] {....raises: [Exception], tags: [RootEffect], forbids: [].}
proc merged[A, B, C, D](self: Dictionary[A, B]; dictionary: Dictionary[C, D];
                        overwrite: bool = false): Dictionary[Variant, Variant]
proc merged[A, B](self: Dictionary[A, B]; dictionary: Dictionary[A, B];
                  overwrite: bool = false): Dictionary[A, B]
proc merged[A, B](self: Dictionary[A, B];
                  dictionary: Dictionary[Variant, Variant];
                  overwrite: bool = false): Dictionary[A, B]
proc merged[A, B](self: Dictionary[Variant, Variant];
                  dictionary: Dictionary[A, B]; overwrite: bool = false): Dictionary[
    A, B]
proc newDictionary(base: Dictionary[Variant, Variant]; keyType: Int;
                   keyClassName: StringName; keyScript: Variant; valueType: Int;
                   valueClassName: StringName; valueScript: Variant): Dictionary[
    Variant, Variant] {....raises: [Exception], tags: [RootEffect], forbids: [].}
proc newDictionary[A, B](): Dictionary[A, B]
proc newDictionary[A, B](from: Dictionary[A, B]): Dictionary[A, B]
proc newDictionary[A, B](pairs: openArray[(A, B)]): Dictionary[A, B]
proc newDictionary[A, B](table: Table[A, B]): Dictionary[A, B]
proc newDictionary[A, B](table: TableRef[A, B]): Dictionary[A, B]
func `not`(left: Dictionary[Variant, Variant]): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc recursiveEqual(self: Dictionary[Variant, Variant];
                    dictionary: Dictionary[Variant, Variant];
                    recursionCount: Int): bool {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc recursiveEqual[A, B, C, D](self: Dictionary[A, B];
                                dictionary: Dictionary[C, D];
                                recursionCount: Int): bool
proc set(self: var Dictionary[Variant, Variant]; key: Variant; value: Variant): bool {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc set[A, B](self: var Dictionary[A, B]; key: A; value: B): bool
proc set[A, B](self: var Dictionary[A, Variant]; key: A; value: B): bool
proc set[A, B](self: var Dictionary[Variant, B]; key: A; value: B): bool
proc set[A, B](self: var Dictionary[Variant, Variant]; key: A; value: B): bool
proc size(self: Dictionary[Variant, Variant]): Int {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc size[A, B](self: Dictionary[A, B]): Int
proc sort(self: var Dictionary[Variant, Variant]): void {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc sort[A, B](self: var Dictionary[A, B]): void
proc values(self: Dictionary[Variant, Variant]): Array[Variant] {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc values[A, B](self: Dictionary[A, B]): Array[B]

Iterators

iterator keys[A, B](self: Dictionary[A, B]): A
iterator mpairs[A; B: SomeBuiltins or Variant](self: var Dictionary[A, B]): tuple[
    key: A, item: var B]
iterator mvalues[A; B: SomeBuiltins or Variant](self: var Dictionary[A, B]): var B
iterator pairs[A, B](self: Dictionary[A, B]): tuple[key: A, item: B]
iterator values[A, B](self: Dictionary[A, B]): B

Made with Nim. Generated: 2025-11-25 08:34:29 UTC