Method from_buffer

aiscript-vm/src/string/interned.rs:43–75

(mc: &Mutation<'gc>, s: Box<[u8]>)

impl<'gc> InternedString<'gc> {
    pub fn from_buffer(mc: &Mutation<'gc>, s: Box<[u8]>) -> InternedString<'gc> {
        #[derive(Collect)]
        #[collect(require_static)]
        #[repr(C)]
        struct Owned {
            header: StringInner,
            metrics: Metrics,
        }

        impl Drop for Owned {
            fn drop(&mut self) {
                match self.header.buffer {
                    Buffer::Indirect(ptr) => unsafe {
                        self.metrics.mark_external_deallocation((*ptr).len());
                        drop(Box::from_raw(ptr as *mut [u8]));
                    },
                    Buffer::Inline(_) => unreachable!(),
                }
            }
        }

        let metrics = mc.metrics().clone();
        metrics.mark_external_allocation(s.len());
        let owned = Owned {
            header: StringInner {
                hash: str_hash(&s),
                buffer: Buffer::Indirect(Box::into_raw(s)),
            },
            metrics,
        };
        // SAFETY: We know we can cast to `StringInner` because `Owned` is `#[repr(C)]`
        InternedString(unsafe { Gc::cast::<StringInner>(Gc::new(mc, owned)) })
    }

    pub fn from_slice(mc: &Mutation<'gc>, s: impl AsRef<[u8]>) -> InternedString<'gc> {
        // TODO: This is an extremely silly way to allocate a dynamically sized, inline string.