Trait PyClassImpl 

pub trait PyClassImpl: Sized + 'static {
    type Layout: PyClassObjectLayout<Self>;
    type BaseType: PyTypeInfo + PyClassBaseType;
    type PyClassMutability: PyClassMutability + GetBorrowChecker<Self>;
    type Dict: PyClassDict;
    type WeakRef: PyClassWeakRef;
    type BaseNativeType: PyTypeInfo;
    type ThreadChecker: PyClassThreadChecker<Self>;

    const MODULE: Option<&'static str>;
    const RAW_DOC: &'static CStr;
    const DOC: &'static CStr;
    const IS_BASETYPE: bool = false;
    const IS_SUBCLASS: bool = false;
    const IS_MAPPING: bool = false;
    const IS_SEQUENCE: bool = false;
    const IS_IMMUTABLE_TYPE: bool = false;

    // Required methods
    fn items_iter() -> PyClassItemsIter ;
    fn lazy_type_object() -> &'static LazyTypeObject<Self>;

    // Provided methods
    fn dict_offset() -> Option<PyObjectOffset> { ... }
    fn weaklist_offset() -> Option<PyObjectOffset> { ... }
}

Implements the underlying functionality of #[pyclass], assembled by various proc macros.

Users are discouraged from implementing this trait manually; it is a PyO3 implementation detail and may be changed at any time.

Required Associated Constants

const MODULE: Option<&'static str>

Module which the class will be associated with.

(Currently defaults to builtins if unset, this will likely be improved in the future, it may also be removed when passing module objects in class init.)

const RAW_DOC: &'static CStr

Docstring for the class provided on the struct or enum.

This is exposed for PyClassDocGenerator to use as a docstring piece.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

This is constructed at compile-time with const specialization via the proc macros with help from the PyClassDocGenerator` type.

Provided Associated Constants

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

Required Associated Types

type Layout: PyClassObjectLayout<Self>

Description of how this class is laid out in memory

type BaseType: PyTypeInfo + PyClassBaseType

Base class

type PyClassMutability: PyClassMutability + GetBorrowChecker<Self>

Immutable or mutable

type Dict: PyClassDict

Specify this class has #[pyclass(dict)] or not.

type WeakRef: PyClassWeakRef

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType: PyTypeInfo

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

type ThreadChecker: PyClassThreadChecker<Self>

This handles following two situations:

1. In case T is Send, stub ThreadChecker is used and does nothing. This implementation is used by default. Compile fails if T: !Send.
2. In case T is !Send, ThreadChecker panics when T is accessed by another thread. This implementation is used when #[pyclass(unsendable)] is given. Panicking makes it safe to expose T: !Send to the Python interpreter, where all objects can be accessed by multiple threads by threading module.

Required Methods

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

Provided Methods

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl PyClassImpl for Coroutine

Available on crate feature experimental-async only.

const MODULE: Option<&str> = ::core::option::Option::None

const IS_BASETYPE: bool = false

const IS_SUBCLASS: bool = false

const IS_MAPPING: bool = false

const IS_SEQUENCE: bool = false

const IS_IMMUTABLE_TYPE: bool = false

const RAW_DOC: &'static CStr = /// Python coroutine wrapping a [`Future`].

const DOC: &'static CStr

type Layout = <<Coroutine as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<Coroutine>

type BaseType = PyAny

type ThreadChecker = NoopThreadChecker

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

type Dict = PyClassDummySlot

type WeakRef = PyClassDummySlot

type BaseNativeType = PyAny