Struct Ref

pub struct Ref<T: ?Sized> { /* private fields */ }

A strong owned reference to the given type that can be safely dereferenced.

Examples

Constructed from a static value:

use rune::Ref;

let value: Ref<str> = Ref::from_static("hello world");

Implementations

impl<T: ?Sized> Ref<T>

pub const fn from_static(value: &'static T) -> Ref<T>

Construct an owned reference from a static value.

Examples

use rune::Ref;

let value: Ref<str> = Ref::from_static("Hello World");
assert_eq!(value.as_ref(), "Hello World");

pub fn map<U: ?Sized, F>(this: Self, f: F) -> Ref<U>

where F: FnOnce(&T) -> &U,

Map the interior reference of an owned mutable value.

Examples

use rune::Ref;
use rune::runtime::Bytes;
use rune::alloc::try_vec;

let bytes = rune::to_value(Bytes::from_vec(try_vec![1, 2, 3, 4]))?;
let bytes: Ref<Bytes> = rune::from_value(bytes)?;
let value: Ref<[u8]> = Ref::map(bytes, |vec| &vec[0..2]);

assert_eq!(&*value, &[1, 2][..]);

pub fn try_map<U: ?Sized, F>(this: Self, f: F) -> Result<Ref<U>, Ref<T>>

where F: FnOnce(&T) -> Option<&U>,

Try to map the reference to a projection.

Examples

use rune::Ref;
use rune::runtime::Bytes;
use rune::alloc::try_vec;

let bytes = rune::to_value(Bytes::from_vec(try_vec![1, 2, 3, 4]))?;
let bytes: Ref<Bytes> = rune::from_value(bytes)?;

let Ok(value) = Ref::try_map(bytes, |bytes| bytes.get(0..2)) else {
    panic!("Conversion failed");
};

assert_eq!(&value[..], &[1, 2][..]);

pub fn into_raw(this: Self) -> (NonNull<T>, RawAnyGuard)

Convert into a raw pointer and associated raw access guard.

Safety

The returned pointer must not outlive the associated guard, since this prevents other uses of the underlying data which is incompatible with the current.

pub unsafe fn from_raw(value: NonNull<T>, guard: RawAnyGuard) -> Self

Convert a raw reference and guard into a regular reference.

Safety

The caller is responsible for ensuring that the raw reference is associated with the specific pointer.

Trait Implementations

impl<T: ?Sized> AsRef<T> for Ref<T>

fn as_ref(&self) -> &T

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

impl<T> Debug for Ref<T>

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T: ?Sized> Deref for Ref<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> From<Arc<T>> for Ref<T>

fn from(value: Arc<T>) -> Ref<T>

Construct from an atomically reference-counted value.

Examples

use std::sync::Arc;
use rune::Ref;

let value: Ref<String> = Ref::from(Arc::new(String::from("hello world")));
assert_eq!(value.as_ref(), "hello world");

impl<T> From<Rc<T>> for Ref<T>

fn from(value: Rc<T>) -> Ref<T>

Construct from an atomically reference-counted value.

Examples

use std::rc::Rc;
use rune::Ref;

let value: Ref<String> = Ref::from(Rc::new(String::from("hello world")));
assert_eq!(value.as_ref(), "hello world");

impl<T> FromValue for Ref<T>

where T: AnyMarker,

fn from_value(value: Value) -> Result<Self, RuntimeError>

Try to convert to the given type, from the given value.

impl FromValue for Ref<Tuple>

fn from_value(value: Value) -> Result<Self, RuntimeError>

Try to convert to the given type, from the given value.

impl FromValue for Ref<str>

fn from_value(value: Value) -> Result<Self, RuntimeError>

Try to convert to the given type, from the given value.

impl<T> MaybeTypeOf for Ref<T>

where T: ?Sized + MaybeTypeOf,

fn maybe_type_of() -> Result<DocType>

Type information for the given type.

impl<T> TypeHash for Ref<T>

where T: ?Sized + TypeHash,

Blanket implementation for owned references.

const HASH: Hash = T::HASH

The complete type hash of the type including type parameters which uniquely identifiers a given type.

impl<T> TypeOf for Ref<T>

where T: ?Sized + TypeOf,

Blanket implementation for owned references.

const PARAMETERS: Hash = T::PARAMETERS

Type parameters for the type.

const STATIC_TYPE_INFO: AnyTypeInfo = T::STATIC_TYPE_INFO

Access diagnostical type information for the current type.

fn type_info() -> TypeInfo

Get type info associated with the current type.