Struct ragged_buffer::monomorphs::RaggedBufferF32

pub struct RaggedBufferF32(pub RaggedBufferView<f32>);

Tuple Fields

0: RaggedBufferView<f32>

Implementations

impl RaggedBufferF32

pub fn new(features: usize) -> Self

Trait Implementations

impl Clone for RaggedBufferF32

fn clone(&self) -> RaggedBufferF32

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl IntoPy<Py<PyAny>> for RaggedBufferF32

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for RaggedBufferF32

type Dict = PyClassDummySlot

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

type WeakRef = PyClassDummySlot

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

type BaseNativeType = PyAny

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

impl PyClassDescriptors<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn py_class_descriptors(self) -> &'static [PyMethodDefType]

impl PyClassImpl for RaggedBufferF32

const DOC: &'static str

Class doc string

const IS_GC: bool

#[pyclass(gc)]

const IS_BASETYPE: bool

#[pyclass(subclass)]

const IS_SUBCLASS: bool

#[pyclass(extends=…)]

type Layout = PyCell<Self>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<RaggedBufferF32>

This handles following two situations:

fn for_each_method_def(visitor: &mut dyn FnMut(&[PyMethodDefType]))

fn get_new() -> Option<newfunc>

fn get_alloc() -> Option<allocfunc>

fn get_free() -> Option<freefunc>

fn for_each_proto_slot(visitor: &mut dyn FnMut(&[PyType_Slot]))

fn get_buffer() -> Option<&'static PyBufferProcs>

impl PyClassNewImpl<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn new_impl(self) -> Option<newfunc>

impl<'p> PyMappingGetItemProtocol<'p> for RaggedBufferF32

type Key = MultiIndex<'p>

type Result = PyResult<RaggedBufferF32>

impl<'p> PyMappingLenProtocol<'p> for RaggedBufferF32

type Result = PyResult<usize>

impl<'p> PyMappingProtocol<'p> for RaggedBufferF32

fn __getitem__(
    &'p self,
    index: <RaggedBufferF32 as PyMappingGetItemProtocol<'p>>::Key
) -> <RaggedBufferF32 as PyMappingGetItemProtocol<'p>>::Result

fn __len__(&'p self) -> <RaggedBufferF32 as PyMappingLenProtocol<'p>>::Result

fn __setitem__(&'p mut self, key: Self::Key, value: Self::Value) -> Self::Result where
    Self: PyMappingSetItemProtocol<'p>, 

fn __delitem__(&'p mut self, key: Self::Key) -> Self::Result where
    Self: PyMappingDelItemProtocol<'p>, 

fn __reversed__(&'p self) -> Self::Result where
    Self: PyMappingReversedProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __reversed__ in #[pymethods] instead of in a protocol

impl PyMappingProtocolSlots<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn mapping_protocol_slots(self) -> &'static [PyType_Slot]

impl PyMethods<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn py_methods(self) -> &'static [PyMethodDefType]

impl PyMethodsProtocolSlots<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn methods_protocol_slots(self) -> &'static [PyType_Slot]

impl<'p> PyNumberAddProtocol<'p> for RaggedBufferF32

type Left = RaggedBufferF32

type Right = RaggedBufferF32OrF32

type Result = PyResult<RaggedBufferF32>

impl<'p> PyNumberISubProtocol<'p> for RaggedBufferF32

type Other = RaggedBufferF32

type Result = PyResult<()>

impl<'p> PyNumberMulProtocol<'p> for RaggedBufferF32

type Left = RaggedBufferF32

type Right = RaggedBufferF32OrF32

type Result = PyResult<RaggedBufferF32>

impl<'p> PyNumberProtocol<'p> for RaggedBufferF32

fn __add__(
    lhs: <RaggedBufferF32 as PyNumberAddProtocol<'p>>::Left,
    rhs: <RaggedBufferF32 as PyNumberAddProtocol<'p>>::Right
) -> <RaggedBufferF32 as PyNumberAddProtocol<'p>>::Result

fn __mul__(
    lhs: <RaggedBufferF32 as PyNumberMulProtocol<'p>>::Left,
    rhs: <RaggedBufferF32 as PyNumberMulProtocol<'p>>::Right
) -> <RaggedBufferF32 as PyNumberMulProtocol<'p>>::Result

fn __isub__(
    &'p mut self,
    rhs: <RaggedBufferF32 as PyNumberISubProtocol<'p>>::Other
) -> <RaggedBufferF32 as PyNumberISubProtocol<'p>>::Result

fn __sub__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberSubProtocol<'p>, 

fn __matmul__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberMatmulProtocol<'p>, 

fn __truediv__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberTruedivProtocol<'p>, 

fn __floordiv__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberFloordivProtocol<'p>, 

fn __mod__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberModProtocol<'p>, 

fn __divmod__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberDivmodProtocol<'p>, 

fn __pow__(
    lhs: Self::Left,
    rhs: Self::Right,
    modulo: Option<Self::Modulo>
) -> Self::Result where
    Self: PyNumberPowProtocol<'p>, 

fn __lshift__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberLShiftProtocol<'p>, 

fn __rshift__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberRShiftProtocol<'p>, 

fn __and__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberAndProtocol<'p>, 

fn __xor__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberXorProtocol<'p>, 

fn __or__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberOrProtocol<'p>, 

fn __radd__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRAddProtocol<'p>, 

fn __rsub__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRSubProtocol<'p>, 

fn __rmul__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRMulProtocol<'p>, 

fn __rmatmul__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRMatmulProtocol<'p>, 

fn __rtruediv__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRTruedivProtocol<'p>, 

fn __rfloordiv__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRFloordivProtocol<'p>, 

fn __rmod__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRModProtocol<'p>, 

fn __rdivmod__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRDivmodProtocol<'p>, 

fn __rpow__(
    &'p self,
    other: Self::Other,
    modulo: Option<Self::Modulo>
) -> Self::Result where
    Self: PyNumberRPowProtocol<'p>, 

fn __rlshift__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRLShiftProtocol<'p>, 

fn __rrshift__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRRShiftProtocol<'p>, 

fn __rand__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRAndProtocol<'p>, 

fn __rxor__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRXorProtocol<'p>, 

fn __ror__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberROrProtocol<'p>, 

fn __iadd__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIAddProtocol<'p>, 

fn __imul__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIMulProtocol<'p>, 

fn __imatmul__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIMatmulProtocol<'p>, 

fn __itruediv__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberITruedivProtocol<'p>, 

fn __ifloordiv__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIFloordivProtocol<'p>, 

fn __imod__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIModProtocol<'p>, 

fn __ipow__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIPowProtocol<'p>, 

fn __ilshift__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberILShiftProtocol<'p>, 

fn __irshift__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIRShiftProtocol<'p>, 

fn __iand__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIAndProtocol<'p>, 

fn __ixor__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIXorProtocol<'p>, 

fn __ior__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIOrProtocol<'p>, 

fn __neg__(&'p self) -> Self::Result where
    Self: PyNumberNegProtocol<'p>, 

fn __pos__(&'p self) -> Self::Result where
    Self: PyNumberPosProtocol<'p>, 

fn __abs__(&'p self) -> Self::Result where
    Self: PyNumberAbsProtocol<'p>, 

fn __invert__(&'p self) -> Self::Result where
    Self: PyNumberInvertProtocol<'p>, 

fn __complex__(&'p self) -> Self::Result where
    Self: PyNumberComplexProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __complex__ in #[pymethods] instead of in a protocol

fn __int__(&'p self) -> Self::Result where
    Self: PyNumberIntProtocol<'p>, 

fn __float__(&'p self) -> Self::Result where
    Self: PyNumberFloatProtocol<'p>, 

fn __index__(&'p self) -> Self::Result where
    Self: PyNumberIndexProtocol<'p>, 

fn __round__(&'p self, ndigits: Option<Self::NDigits>) -> Self::Result where
    Self: PyNumberRoundProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __round__ in #[pymethods] instead of in a protocol

impl PyNumberProtocolSlots<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn number_protocol_slots(self) -> &'static [PyType_Slot]

impl<'p> PyObjectProtocol<'p> for RaggedBufferF32

fn __str__(&'p self) -> <RaggedBufferF32 as PyObjectStrProtocol<'p>>::Result

fn __repr__(&'p self) -> <RaggedBufferF32 as PyObjectReprProtocol<'p>>::Result

fn __richcmp__(
    &'p self,
    other: <RaggedBufferF32 as PyObjectRichcmpProtocol<'p>>::Other,
    op: CompareOp
) -> <RaggedBufferF32 as PyObjectRichcmpProtocol<'p>>::Result

fn __getattr__(&'p self, name: Self::Name) -> Self::Result where
    Self: PyObjectGetAttrProtocol<'p>, 

fn __setattr__(
    &'p mut self,
    name: Self::Name,
    value: Self::Value
) -> Self::Result where
    Self: PyObjectSetAttrProtocol<'p>, 

fn __delattr__(&'p mut self, name: Self::Name) -> Self::Result where
    Self: PyObjectDelAttrProtocol<'p>, 

fn __format__(&'p self, format_spec: Self::Format) -> Self::Result where
    Self: PyObjectFormatProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __format__ in #[pymethods] instead of in a protocol

fn __hash__(&'p self) -> Self::Result where
    Self: PyObjectHashProtocol<'p>, 

fn __bytes__(&'p self) -> Self::Result where
    Self: PyObjectBytesProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __bytes__ in #[pymethods] instead of in a protocol

fn __bool__(&'p self) -> Self::Result where
    Self: PyObjectBoolProtocol<'p>, 

impl PyObjectProtocolSlots<RaggedBufferF32> for PyClassImplCollector<RaggedBufferF32>

fn object_protocol_slots(self) -> &'static [PyType_Slot]

impl<'p> PyObjectReprProtocol<'p> for RaggedBufferF32

type Result = PyResult<String>

impl<'p> PyObjectRichcmpProtocol<'p> for RaggedBufferF32

type Other = RaggedBufferF32

type Result = PyResult<bool>

impl<'p> PyObjectStrProtocol<'p> for RaggedBufferF32

type Result = PyResult<String>

impl PyTypeInfo for RaggedBufferF32

type AsRefTarget = PyCell<Self>

Utility type to make Py::as_ref work.

const NAME: &'static str

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

PyTypeObject instance for this type.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.