class Godot::Dictionary

Overview

A high-level Crystal wrapper around Godot's native Dictionary type. Provides seamless indexing, Enumerable iteration, and conversion to/from Crystal Hash.

Included Modules

Defined in:

libgodot/collections.cr
libgodot/variant.cr

Constructors

Instance Method Summary

Instance methods inherited from class Object

try?(&)
try? try?

Constructor Detail

def self.from(hash : Hash(K, V)) : Dictionary forall K, V #

Creates a Godot::Dictionary from any Crystal Hash


def self.from_bridge_payload(payload_ptr : Pointer(Void)) : Dictionary #

def self.new(initial_hash : Hash(K, V)) forall K, V #

def self.new #

def self.new(**kwargs) #

Instance Method Detail

def [](key : Variant) : Variant #

Retrieves value by key, or produces KeyError if missing


def [](key : String) : Variant #

def [](key : Symbol) : Variant #

def []=(key : Variant, value : Variant) : Variant #

Sets or updates a key-value pair


def []=(key : String, value : Variant) : Variant #

def []=(key : Symbol, value : Variant) : Variant #

def []=(key : String | Symbol | Variant, value) #

def []?(key : Variant) : Variant | Nil #

Retrieves value by key, or returns nil if missing


def []?(key : String) : Variant | Nil #

def []?(key : Symbol) : Variant | Nil #

def clear : Void #

def clone : Dictionary #

def delete(key : Variant) : Variant | Nil #

def delete(key : String) : Variant | Nil #

def delete(key : Symbol) : Variant | Nil #

def dig?(first : String | Symbol | Variant, *rest, as type : T.class) : {Godot::Variant, Godot::Variant} | Nil forall T #

Digs through nested Dictionaries by keys, returning typed value or nil


def dup : Dictionary #
Description copied from class Reference

Returns a shallow copy of this object.

This allocates a new object and copies the contents of self into it.


def duplicate(deep : Bool = false) : Dictionary #

def each(& : Tuple(Variant, Variant) -> ) : Void #
Description copied from module Enumerable({Godot::Variant, Godot::Variant})

Must yield this collection's elements to the block.


def empty? : Bool #
Description copied from module Enumerable({Godot::Variant, Godot::Variant})

Returns true if self does not contain any element.

([] of Int32).empty? # => true
([1]).empty?         # => false
[nil, false].empty?  # => false
  • #present? returns the inverse.

def erase(key : Variant) : Void #

def erase(key : String) : Void #

def erase(key : Symbol) : Void #

def get(key : String | Symbol | Variant, as type : T.class, default : {Godot::Variant, Godot::Variant}) : {Godot::Variant, Godot::Variant} forall T #

Generic typed getter with default value


def get?(key : String | Symbol | Variant, as type : T.class) : {Godot::Variant, Godot::Variant} | Nil forall T #

Generic safe typed getter returning nil on missing or type mismatch


def has(key : Variant) : Bool #

def has(key : String) : Bool #

def has(key : Symbol) : Bool #

def has_key?(key : Variant) : Bool #

def has_key?(key : String) : Bool #

def has_key?(key : Symbol) : Bool #

def is_empty : Bool #

def keys : Array(Variant) #

def size : Int64 #
Description copied from module Enumerable({Godot::Variant, Godot::Variant})

Returns the number of elements in the collection.

[1, 2, 3, 4].size # => 4

def to_h : Hash(String, String) #

Converts back to a standard Crystal Hash


def to_s(io : IO) : Void #
Description copied from class Reference

Appends a short String representation of this object which includes its class name and its object address.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>

def values : Array(Variant) #

def write_bridge_payload(ret_ptr : Pointer(Void)) : Void #