Struct ext_php_rs::describe::abi::Str

#[repr(C)]
pub struct Str { /* private fields */ }

An immutable, ABI-stable borrowed &'static str.

Implementations

impl Str

pub fn str(&self) -> &'static str

Returns the string as a string slice.

The lifetime is 'static and can outlive the Str object, as you can only initialize a Str through a static reference.

Examples found in repository

src/describe/abi.rs (line 76)

    fn as_ref(&self) -> &str {
        self.str()
    }
}

impl Display for Str {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.str().fmt(f)
    }

src/describe/stub.rs (line 211)

    fn fmt_stub(&self, buf: &mut String) -> FmtResult {
        self.docs.fmt_stub(buf)?;

        let (_, name) = split_namespace(self.name.as_ref());
        write!(buf, "class {} ", name)?;

        if let Option::Some(extends) = &self.extends {
            write!(buf, "extends {} ", extends)?;
        }

        if !self.implements.is_empty() {
            write!(
                buf,
                "implements {} ",
                self.implements
                    .iter()
                    .map(|s| s.str())
                    .collect::<StdVec<_>>()
                    .join(", ")
            )?;
        }

        writeln!(buf, "{{")?;

        fn stub<T: ToStub>(items: &[T]) -> impl Iterator<Item = Result<String, FmtError>> + '_ {
            items
                .iter()
                .map(|item| item.to_stub().map(|stub| indent(&stub, 4)))
        }

        buf.push_str(
            &stub(&self.constants)
                .chain(stub(&self.properties))
                .chain(stub(&self.methods))
                .collect::<Result<StdVec<_>, FmtError>>()?
                .join(NEW_LINE_SEPARATOR),
        );

        writeln!(buf, "}}")
    }

Trait Implementations

impl AsRef<str> for Str

fn as_ref(&self) -> &str

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

impl Display for Str

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

Formats the value using the given formatter.

impl From<&'static str> for Str

fn from(val: &'static str) -> Self

Converts to this type from the input type.