Struct PyDict 

pub struct PyDict { /* private fields */ }

Implementations

impl PyDict

pub fn new_ref(ctx: &Context) -> PyRef<Self>

👎Deprecated:

use PyDict::default().into_ref() instead

pub fn keys_vec(&self) -> Vec<PyObjectRef>

Returns all keys as a Vec, atomically under a single read lock. Thread-safe: prevents “dictionary changed size during iteration” errors.

pub fn values_vec(&self) -> Vec<PyObjectRef>

Returns all values as a Vec, atomically under a single read lock. Thread-safe: prevents “dictionary changed size during iteration” errors.

pub fn items_vec(&self) -> Vec<(PyObjectRef, PyObjectRef)>

Returns all items as a Vec, atomically under a single read lock. Thread-safe: prevents “dictionary changed size during iteration” errors.

pub fn is_empty(&self) -> bool

pub fn get_or_insert( &self, vm: &VirtualMachine, key: PyObjectRef, default: impl FnOnce() -> PyObjectRef, ) -> PyResult

pub fn from_attributes( attrs: IndexMap<&'static PyStrInterned, PyObjectRef, RandomState>, vm: &VirtualMachine, ) -> PyResult<Self>

pub fn contains_key<K: DictKey + ?Sized>( &self, key: &K, vm: &VirtualMachine, ) -> bool

pub fn size(&self) -> DictSize

impl PyDict

pub fn __len__(&self) -> usize

pub fn clear(&self)

pub fn copy(&self) -> Self

Trait Implementations

impl AsMapping for PyDict

fn as_mapping() -> &'static PyMappingMethods

fn mapping_downcast(mapping: PyMapping<'_>) -> &Py<Self>

fn extend_slots(slots: &mut PyTypeSlots)

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl AsNumber for PyDict

fn as_number() -> &'static PyNumberMethods

fn extend_slots(slots: &mut PyTypeSlots)

fn clone_exact(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyRef<Self>

fn number_downcast(num: PyNumber<'_>) -> &Py<Self>

fn number_downcast_exact(num: PyNumber<'_>, vm: &VirtualMachine) -> PyRef<Self>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl AsSequence for PyDict

fn as_sequence() -> &'static PySequenceMethods

fn sequence_downcast(seq: PySequence<'_>) -> &Py<Self>

fn extend_slots(slots: &mut PyTypeSlots)

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Comparable for PyDict

fn cmp( zelf: &Py<Self>, other: &PyObject, op: PyComparisonOp, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn slot_richcompare( zelf: &PyObject, other: &PyObject, op: PyComparisonOp, vm: &VirtualMachine, ) -> PyResult<Either<PyObjectRef, PyComparisonValue>>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Debug for PyDict

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PyDict

fn default() -> PyDict

Returns the “default value” for a type.

impl DefaultConstructor for PyDict

fn construct_and_init( args: Self::Args, vm: &VirtualMachine, ) -> PyResult<PyRef<Self>>

where Self: Initializer,

impl Initializer for PyDict

type Args = (OptionalArg, KwArgs)

fn init( zelf: PyRef<Self>, (dict_obj, kwargs): Self::Args, vm: &VirtualMachine, ) -> PyResult<()>

fn slot_init( zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine, ) -> PyResult<()>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl<'a> IntoIterator for &'a PyDict

type Item = (PyObjectRef, PyObjectRef)

The type of the elements being iterated over.

type IntoIter = DictIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Iterable for PyDict

fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult

fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult

fn extend_slots(_slots: &mut PyTypeSlots)

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl MaybeTraverse for PyDict

const HAS_TRAVERSE: bool = true

if is traceable, will be used by vtable to determine

const HAS_CLEAR: bool = true

if has clear implementation for circular reference resolution (tp_clear)

fn try_traverse(&self, tracer_fn: &mut TraverseFn<'_>)

fn try_clear(&mut self, out: &mut Vec<PyObjectRef>)

impl PyClassDef for PyDict

const NAME: &'static str = "dict"

const MODULE_NAME: Option<&'static str> = None

const TP_NAME: &'static str = "dict"

const DOC: Option<&'static str>

const BASICSIZE: usize

const UNHASHABLE: bool = true

type Base = PyBaseObject

const ITEMSIZE: usize = 0

impl PyClassImpl for PyDict

const TP_FLAGS: PyTypeFlags

const METHOD_DEFS: &'static [PyMethodDef]

fn impl_extend_class(ctx: &'static Context, class: &'static Py<PyType>)

fn extend_slots(slots: &mut PyTypeSlots)

fn extend_class(ctx: &'static Context, class: &'static Py<PyType>)

where Self: Sized,

fn make_static_type() -> PyTypeRef

where Self: StaticType + Sized,

fn make_slots() -> PyTypeSlots

impl PyPayload for PyDict

const MAX_FREELIST: usize = 80

Maximum number of objects to keep in the freelist.

const HAS_FREELIST: bool = true

Whether this type has a freelist. Types with freelists require immediate (non-deferred) GC untracking during dealloc to prevent race conditions when the object is reused.

fn class(ctx: &Context) -> &'static Py<PyType>

unsafe fn freelist_push(obj: *mut PyObject) -> bool

Try to push a dead object onto this type’s freelist for reuse. Returns true if the object was stored (caller must NOT free the memory). Called before tp_clear, so the payload is still intact.

unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>>

Try to pop a pre-allocated object from this type’s freelist. The returned pointer still has the old payload; the caller must reinitialize ref_count, gc_bits, and payload.

const PAYLOAD_TYPE_ID: TypeId = _

unsafe fn validate_downcastable_from(_obj: &PyObject) -> bool

Safety

fn try_downcast_from(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()>

fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef

where Self: Debug,

fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self>

where Self: Debug,

fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self>

where Self: Debug,

fn into_ref(self, ctx: &Context) -> PyRef<Self>

where Self: Debug,

fn into_ref_with_type( self, vm: &VirtualMachine, cls: PyTypeRef, ) -> PyResult<PyRef<Self>>

where Self: Debug,

impl Representable for PyDict

fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef>

fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String>

fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>>

fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl StaticType for PyDict

fn static_cell() -> &'static StaticCell<PyTypeRef>

fn static_metaclass() -> &'static Py<PyType>

fn static_baseclass() -> &'static Py<PyType>

fn static_type() -> &'static Py<PyType>

fn init_manually(typ: PyTypeRef) -> &'static Py<PyType>

fn init_builtin_type() -> &'static Py<PyType>

where Self: PyClassImpl,

fn create_static_type() -> PyTypeRef

where Self: PyClassImpl,

impl Traverse for PyDict

fn traverse(&self, traverse_fn: &mut TraverseFn<'_>)

impl traverse() with caution! Following those guideline so traverse doesn’t cause memory error!:

fn clear(&mut self, out: &mut Vec<PyObjectRef>)

Extract all owned child PyObjectRefs for circular reference resolution (tp_clear). Called just before object deallocation to break circular references. Default implementation does nothing.