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 contains_nuls(&self) -> bool

Check string bytes for interior NULs.

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 as_utf8(&self) -> Option<&PyUtf8Str>

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 fn char_index_to_byte(&self, index: usize) -> usize

The byte offset the index-th character starts at, or the string’s byte length if index is at or past its end.

pub fn byte_to_char_index(&self, bytepos: usize) -> usize

The character index of the character starting at byte offset bytepos, which must be a character boundary at or before the end.

pub fn __mod__( &self, values: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<Wtf8Buf>

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 DROP_KWARGS_WHEN_INIT_OVERRIDDEN: bool = false

When true, extra keywords are dropped if a subclass replaced tp_init.

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: ItemDoc

const ATTR_DOCS: &'static [(&'static str, u32, u32)]

Attribute name → database span, sorted by name. (u32::MAX, 0) is an explicit empty doc.

const BASICSIZE: usize

const UNHASHABLE: bool = false

const MEMBERS: &'static [PyMemberSpec]

type Base = PyBaseObject

fn assert_member_layout()

const ITEMSIZE: usize = 0

impl PyClassImpl for PyStr

const TP_FLAGS: PyTypeFlags

const INTERNAL_DOC: ItemDoc

Signature-bearing class doc. ItemDoc::NONE when the constructor has no signature.

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 NEW_REF_UNTRACKED: bool = false

Whether PyRef::new_ref skips auto-tracking this type in the GC even when it would otherwise qualify (has traverse, dict, or heap type). Such objects are created untracked and must be tracked explicitly if and when they can become part of a reference cycle. Used by FrameObject, which is created untracked and tracked lazily only on escape.

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 after tp_clear, so the payload is a cleared husk; implementations must not rely on its pre-clear contents.

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,

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

where Self: Debug,

Like into_ref_with_type, but leaves the instance __dict__ unallocated until the first attribute write or __dict__ access. Only valid for types whose attribute protocol materializes the dict lazily via get_or_insert.

fn into_ref_with_type_and_dict( self, vm: &VirtualMachine, cls: PyTypeRef, eager_dict: bool, ) -> 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 getitem_by_index( &self, vm: &VirtualMachine, index: isize, ) -> PyResult<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>

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>

impl Wtf8Concat for PyStr

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