Refactor map handling: Replace OwnedMap with Map

- Updated instances of OwnedMap to use Map in various modules including main.rs, core.rs, and function.rs.
- Adjusted function signatures and return types to reflect the change from OwnedMap to Map.
- Modified tests to accommodate the new Map structure instead of OwnedMap.
- Removed unused references and definitions related to OwnedMap.
- Enhanced data handling in the map module to improve safety and performance.

Author: animafps

rspipe/src/main.rs

@@ -1,7 +1,7 @@
 use clap::{Arg, ArgAction, Command};
 use rustsynth::{
     core::{CoreCreationFlags, CoreRef},
-    map::OwnedMap,
+    map::Map,
     vsscript::Environment,
 };
 use std::collections::HashMap;
@@ -138,7 +138,7 @@ fn main() {
             }
         }
 
-        let mut vars_map = OwnedMap::new();
+        let mut vars_map = Map::new();
         for (key, value) in script_args {
             if let Err(e) = vars_map.set(&key, &value) {
                 eprintln!("Failed to set script variable {}: {}", key, e);

rustsynth/src/api.rs

@@ -1,6 +1,7 @@
 //! Module for interacting with the VapourSynth API
 use rustsynth_sys as ffi;
 use std::{
+    borrow::Cow,
     ffi::{c_char, c_int, c_void},
     ptr::{self, NonNull},
     sync::atomic::{AtomicPtr, Ordering},
@@ -738,7 +739,7 @@ impl API {
     pub(crate) fn get_audio_format_name(
         &self,
         format: *const ffi::VSAudioFormat,
-    ) -> Option<String> {
+    ) -> Option<Cow<'_, str>> {
         let mut buf = [0i8; 32]; // Buffer for up to 32 characters as per API docs
         let result =
             unsafe { self.handle.as_ref().getAudioFormatName.unwrap()(format, buf.as_mut_ptr()) };
@@ -747,7 +748,7 @@ impl API {
         } else {
             // Find the null terminator and create a CStr from the buffer
             let cstr = unsafe { std::ffi::CStr::from_ptr(buf.as_ptr()) };
-            Some(cstr.to_string_lossy().into_owned())
+            Some(cstr.to_string_lossy())
         }
     }
 

rustsynth/src/core.rs

@@ -5,7 +5,7 @@ use crate::{
     format::VideoFormat,
     frame::{Frame, FrameContext},
     log::{log_handler_callback, LogHandle, LogHandler, MessageType},
-    map::OwnedMap,
+    map::Map,
     plugin::Plugin,
 };
 use bitflags::bitflags;
@@ -208,11 +208,11 @@ impl<'core> CoreRef<'core> {
     }
 
     /// Create a video filter using the Filter trait
-    pub fn create_video_filter<F>(&self, filter: &F) -> Result<OwnedMap<'_>, String>
+    pub fn create_video_filter<F>(&self, filter: &F) -> Result<Map<'_>, String>
     where
         F: Filter<'core>,
     {
-        let out = OwnedMap::new();
+        let out = Map::new();
         // Get video info from the filter
         let video_info = filter.get_video_info()?;
         let dependencies = filter.get_dependencies();
@@ -288,11 +288,11 @@ impl<'core> CoreRef<'core> {
     }
 
     /// Create a audio filter using the Filter trait
-    pub fn create_audio_filter<F>(&self, filter: &F) -> Result<OwnedMap<'_>, String>
+    pub fn create_audio_filter<F>(&self, filter: &F) -> Result<Map<'_>, String>
     where
         F: Filter<'core>,
     {
-        let out = OwnedMap::new();
+        let out = Map::new();
         // Get audio info from the filter
         let audio_info = filter.get_audio_info()?;
         let dependencies = filter.get_dependencies();

rustsynth/src/format/audio.rs

@@ -163,7 +163,11 @@ impl AudioFormat {
     }
 
     pub fn get_name(&self) -> Option<String> {
-        unsafe { API::get_cached().get_audio_format_name(&self.as_ffi()) }
+        unsafe {
+            API::get_cached()
+                .get_audio_format_name(&self.as_ffi())
+                .map(|f| f.into_owned())
+        }
     }
 
     pub const STEREO16: Self = Self {

rustsynth/src/frame/mod.rs

@@ -1,15 +1,15 @@
 //! Module for frame related types and functionality.
 mod enums;
 
-use std::{marker::PhantomData, ops::Deref, ptr::NonNull};
+use std::{borrow::Cow, marker::PhantomData, ops::Deref, ptr::NonNull};
 
 use rustsynth_sys as ffi;
 
 use crate::{
     api::API,
     core::CoreRef,
     format::{AudioFormat, MediaType, VideoFormat},
-    map::{MapRef, MapRefMut, MapResult},
+    map::{Map, MapResult},
 };
 
 // One frame of a clip.
@@ -248,16 +248,16 @@ impl<'core> Frame<'core> {
 
     /// Get read-only access to frame properties
     #[inline]
-    pub fn properties(&self) -> MapRef<'_, 'core> {
+    pub fn properties(&self) -> Map<'core> {
         let map_ptr = unsafe { API::get_cached().get_frame_props_ro(self.handle.as_ref()) };
-        unsafe { MapRef::from_ptr(map_ptr) }
+        unsafe { Map::from_ptr(map_ptr) }
     }
 
     /// Get read-write access to frame properties (only for owned frames)
     #[inline]
-    pub fn properties_mut(&mut self) -> MapRefMut<'_, 'core> {
+    pub fn properties_mut(&mut self) -> Map<'core> {
         let map_ptr = unsafe { API::get_cached().get_frame_props_rw(self.handle.as_ptr()) };
-        unsafe { MapRefMut::from_ptr(map_ptr) }
+        unsafe { Map::from_ptr(map_ptr) }
     }
 
     // Standard frame property getters
@@ -384,7 +384,7 @@ impl<'core> Frame<'core> {
     }
 
     /// Get picture type (single character describing frame type)
-    pub fn picture_type(&self) -> Option<String> {
+    pub fn picture_type(&self) -> Option<Cow<'core, str>> {
         unsafe {
             self.properties()
                 .get_string_raw_unchecked(c"_PictType", 0)

rustsynth/src/function.rs

@@ -9,7 +9,7 @@ use std::{mem, panic, process};
 
 use crate::api::API;
 use crate::core::CoreRef;
-use crate::map::{Map, MapRef, MapRefMut};
+use crate::map::Map;
 
 /// Holds a reference to a function that may be called.
 #[derive(Debug, PartialEq, Eq)]
@@ -78,8 +78,8 @@ impl<'core> Function<'core> {
         {
             let closure = move || {
                 let core = CoreRef::from_ptr(core);
-                let in_ = MapRef::from_ptr(in_);
-                let mut out = MapRefMut::from_ptr(out);
+                let in_ = Map::from_ptr(in_);
+                let mut out = Map::from_ptr(out);
                 let callback = Box::from_raw(user_data as *mut F);
 
                 callback(core, &in_, &mut out);

rustsynth/src/lib.rs

@@ -59,7 +59,7 @@ pub fn api_version() -> i32 {
 macro_rules! owned_map {
     ($({$key:literal: $x:expr }),*) => {
         {
-            let mut temp_map = $crate::map::OwnedMap::new();
+            let mut temp_map = $crate::map::Map::new();
             $(
                 temp_map.set($key, $x).unwrap();
             )*

rustsynth/src/map/data.rs

@@ -3,17 +3,19 @@ use std::ops::Deref;
 
 #[derive(Clone, Copy, Debug)]
 pub enum DataType {
-    String,
-    Binary,
-    Unknown,
+    String = 1,
+    Binary = 0,
+    Unknown = -1,
 }
 
-pub fn handle_data_hint(hint: i32) -> DataType {
-    match hint {
-        x if x == ffi::VSDataTypeHint::dtBinary as i32 => DataType::Binary,
-        x if x == ffi::VSDataTypeHint::dtUtf8 as i32 => DataType::String,
-        x if x == ffi::VSDataTypeHint::dtUnknown as i32 => DataType::Unknown,
-        _ => unreachable!(),
+impl DataType {
+    pub fn from_hint(value: i32) -> Self {
+        match value {
+            x if x == ffi::VSDataTypeHint::dtBinary as i32 => DataType::Binary,
+            x if x == ffi::VSDataTypeHint::dtUtf8 as i32 => DataType::String,
+            x if x == ffi::VSDataTypeHint::dtUnknown as i32 => DataType::Unknown,
+            _ => DataType::Unknown,
+        }
     }
 }
 

rustsynth/src/map/iterators.rs

@@ -171,7 +171,7 @@ impl<'map, 'elem> Iterator for ValueIter<'map, 'elem, String> {
         };
         self.index += 1;
 
-        Some(value)
+        Some(value.into_owned())
     }
 
     #[inline]