Struct PyStr 

pub struct PyStr { /* private fields */ }

Implementations

impl PyStr

pub unsafe fn new_ascii_unchecked(bytes: Vec<u8>) -> Self

Safety

Given bytes must be ascii

pub fn new_ref(zelf: impl Into<Self>, ctx: &Context) -> PyRef<Self>

👎Deprecated:

use PyStr::from(…).into_ref() instead

pub const fn as_wtf8(&self) -> &Wtf8

pub const fn as_bytes(&self) -> &[u8]

pub fn to_str(&self) -> Option<&str>

pub fn expect_str(&self) -> &str

Returns &str

Panic

If the string contains surrogates.

pub fn to_string_lossy(&self) -> Cow<'_, str>

pub const fn kind(&self) -> StrKind

pub fn as_str_kind(&self) -> PyKindStr<'_>

pub const fn is_utf8(&self) -> bool

pub fn try_as_utf8<'a>(&'a self, vm: &VirtualMachine) -> PyResult<&'a PyUtf8Str>

impl PyStr

pub fn byte_len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn char_len(&self) -> usize

pub const fn isascii(&self) -> bool

pub fn isidentifier(&self) -> bool

Trait Implementations

impl AsMapping for PyStr

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 PyStr

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 AsRef<Wtf8> for PyStr

fn as_ref(&self) -> &Wtf8

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<str> for PyStr

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl AsSequence for PyStr

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 PyStr

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 Constructor for PyStr

type Args = StrArgs

fn slot_new( cls: PyTypeRef, func_args: FuncArgs, vm: &VirtualMachine, ) -> PyResult

The type slot for __new__. Override this only when you need special behavior beyond simple payload creation.

fn py_new( _cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine, ) -> PyResult<Self>

Creates the payload for this type. In most cases, just implement this method and let the default slot_new handle wrapping with the correct type.

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 PyStr

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

Formats the value using the given formatter.

impl Default for PyStr

fn default() -> Self

Returns the “default value” for a type.

impl Display for PyStr

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

Formats the value using the given formatter.

impl<'a> From<&'a AsciiStr> for PyStr

fn from(s: &'a AsciiStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Wtf8> for PyStr

fn from(s: &'a Wtf8) -> Self

Converts to this type from the input type.

impl<'a> From<&'a str> for PyStr

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl From<AsciiChar> for PyStr

fn from(ch: AsciiChar) -> Self

Converts to this type from the input type.

impl From<AsciiString> for PyStr

fn from(s: AsciiString) -> Self

Converts to this type from the input type.

impl From<Box<AsciiStr>> for PyStr

fn from(s: Box<AsciiStr>) -> Self

Converts to this type from the input type.

impl From<Box<Wtf8>> for PyStr

fn from(value: Box<Wtf8>) -> Self

Converts to this type from the input type.

impl From<Box<str>> for PyStr

fn from(value: Box<str>) -> Self

Converts to this type from the input type.

impl From<CodePoint> for PyStr

fn from(ch: CodePoint) -> Self

Converts to this type from the input type.

impl<'a> From<Cow<'a, str>> for PyStr

fn from(s: Cow<'a, str>) -> Self

Converts to this type from the input type.

impl From<StrData> for PyStr

fn from(data: StrData) -> Self

Converts to this type from the input type.

impl From<String> for PyStr

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Wtf8Buf> for PyStr

fn from(w: Wtf8Buf) -> Self

Converts to this type from the input type.

impl From<char> for PyStr

fn from(ch: char) -> Self

Converts to this type from the input type.

impl Hashable for PyStr

fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash>

fn slot_hash(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

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

fn __extend_slots(slots: &mut PyTypeSlots)

impl Iterable for PyStr

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 PyStr

const HAS_TRAVERSE: bool = false

if is traceable, will be used by vtable to determine

const HAS_CLEAR: bool = false

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 PyStr

const NAME: &'static str = "str"

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

const TP_NAME: &'static str = "str"

const DOC: Option<&'static str>

const BASICSIZE: usize

const UNHASHABLE: bool = false

type Base = PyBaseObject

const ITEMSIZE: usize = 0

impl PyClassImpl for PyStr

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 PyStr

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

const PAYLOAD_TYPE_ID: TypeId = _

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

Safety

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

const HAS_FREELIST: bool = false

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.

const MAX_FREELIST: usize = 0

Maximum number of objects to keep in the freelist.

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.

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 PyStr

fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String>

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

fn repr(zelf: &Py<Self>, 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 SliceableSequenceOp for PyStr

type Item = CodePoint

type Sliced = PyStr

fn do_get(&self, index: usize) -> Self::Item

fn do_slice(&self, range: Range<usize>) -> Self::Sliced

fn do_slice_reverse(&self, range: Range<usize>) -> Self::Sliced

fn do_stepped_slice(&self, range: Range<usize>, step: usize) -> Self::Sliced

fn do_stepped_slice_reverse( &self, range: Range<usize>, step: usize, ) -> Self::Sliced

fn empty() -> Self::Sliced

fn len(&self) -> usize

fn wrap_index(&self, p: isize) -> Option<usize>

fn saturate_index(&self, p: isize) -> usize

fn getitem_by_slice( &self, _vm: &VirtualMachine, slice: SaturatedSlice, ) -> PyResult<Self::Sliced>

fn getitem_by_index( &self, vm: &VirtualMachine, index: isize, ) -> PyResult<Self::Item>

impl StaticType for PyStr

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 ToCString for PyStr

fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<CString>

fn ensure_no_nul(&self, vm: &VirtualMachine) -> PyResult<()>

impl Wtf8Concat for PyStr

fn fmt_wtf8(&self, buf: &mut Wtf8Buf)