Vendor dependencies for 0.3.0 release

vendor/windows-collections/src/iterable.rs

@@ -0,0 +1,94 @@
+use super::*;
+use windows_core::*;
+
+#[implement(IIterable<T>)]
+struct StockIterable<T>
+where
+    T: RuntimeType + 'static,
+    T::Default: Clone,
+{
+    values: Vec<T::Default>,
+}
+
+impl<T> IIterable_Impl<T> for StockIterable_Impl<T>
+where
+    T: RuntimeType,
+    T::Default: Clone,
+{
+    fn First(&self) -> Result<IIterator<T>> {
+        Ok(ComObject::new(StockIterator {
+            owner: self.to_object(),
+            current: 0.into(),
+        })
+        .into_interface())
+    }
+}
+
+#[implement(IIterator<T>)]
+struct StockIterator<T>
+where
+    T: RuntimeType + 'static,
+    T::Default: Clone,
+{
+    owner: ComObject<StockIterable<T>>,
+    current: std::sync::atomic::AtomicUsize,
+}
+
+impl<T> IIterator_Impl<T> for StockIterator_Impl<T>
+where
+    T: RuntimeType,
+    T::Default: Clone,
+{
+    fn Current(&self) -> Result<T> {
+        let owner: &StockIterable<T> = &self.owner;
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+
+        if self.owner.values.len() > current {
+            T::from_default(&owner.values[current])
+        } else {
+            Err(Error::from(E_BOUNDS))
+        }
+    }
+
+    fn HasCurrent(&self) -> Result<bool> {
+        let owner: &StockIterable<T> = &self.owner;
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+
+        Ok(owner.values.len() > current)
+    }
+
+    fn MoveNext(&self) -> Result<bool> {
+        let owner: &StockIterable<T> = &self.owner;
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+
+        if current < owner.values.len() {
+            self.current
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        }
+
+        Ok(owner.values.len() > current + 1)
+    }
+
+    fn GetMany(&self, values: &mut [T::Default]) -> Result<u32> {
+        let owner: &StockIterable<T> = &self.owner;
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+        let actual = std::cmp::min(owner.values.len() - current, values.len());
+        let (values, _) = values.split_at_mut(actual);
+        values.clone_from_slice(&owner.values[current..current + actual]);
+
+        self.current
+            .fetch_add(actual, std::sync::atomic::Ordering::Relaxed);
+
+        Ok(actual as u32)
+    }
+}
+
+impl<T> From<Vec<T::Default>> for IIterable<T>
+where
+    T: RuntimeType,
+    T::Default: Clone,
+{
+    fn from(values: Vec<T::Default>) -> Self {
+        ComObject::new(StockIterable { values }).into_interface()
+    }
+}

vendor/windows-collections/src/lib.rs

@@ -0,0 +1,21 @@
+#![doc = include_str!("../readme.md")]
+#![cfg_attr(all(not(feature = "std")), no_std)]
+#![expect(
+    missing_docs,
+    non_snake_case,
+    non_camel_case_types,
+    clippy::missing_transmute_annotations
+)]
+
+mod bindings;
+pub use bindings::*;
+
+#[cfg(feature = "std")]
+const E_BOUNDS: windows_core::HRESULT = windows_core::HRESULT(0x8000000B_u32 as _);
+
+#[cfg(feature = "std")]
+mod iterable;
+#[cfg(feature = "std")]
+mod map_view;
+#[cfg(feature = "std")]
+mod vector_view;

vendor/windows-collections/src/map_view.rs

@@ -0,0 +1,164 @@
+use super::*;
+use windows_core::*;
+
+#[implement(IMapView<K, V>, IIterable<IKeyValuePair<K, V>>)]
+struct StockMapView<K, V>
+where
+    K: RuntimeType + 'static,
+    V: RuntimeType + 'static,
+    K::Default: Clone + Ord,
+    V::Default: Clone,
+{
+    map: std::collections::BTreeMap<K::Default, V::Default>,
+}
+
+impl<K, V> IIterable_Impl<IKeyValuePair<K, V>> for StockMapView_Impl<K, V>
+where
+    K: RuntimeType,
+    V: RuntimeType,
+    K::Default: Clone + Ord,
+    V::Default: Clone,
+{
+    fn First(&self) -> Result<IIterator<IKeyValuePair<K, V>>> {
+        Ok(ComObject::new(StockMapViewIterator::<K, V> {
+            _owner: self.to_object(),
+            current: std::sync::RwLock::new(self.map.iter()),
+        })
+        .into_interface())
+    }
+}
+
+impl<K, V> IMapView_Impl<K, V> for StockMapView_Impl<K, V>
+where
+    K: RuntimeType,
+    V: RuntimeType,
+    K::Default: Clone + Ord,
+    V::Default: Clone,
+{
+    fn Lookup(&self, key: Ref<K>) -> Result<V> {
+        let value = self.map.get(&*key).ok_or_else(|| Error::from(E_BOUNDS))?;
+
+        V::from_default(value)
+    }
+
+    fn Size(&self) -> Result<u32> {
+        Ok(self.map.len().try_into()?)
+    }
+
+    fn HasKey(&self, key: Ref<K>) -> Result<bool> {
+        Ok(self.map.contains_key(&*key))
+    }
+
+    fn Split(&self, first: OutRef<IMapView<K, V>>, second: OutRef<IMapView<K, V>>) -> Result<()> {
+        _ = first.write(None);
+        _ = second.write(None);
+        Ok(())
+    }
+}
+
+#[implement(IIterator<IKeyValuePair<K, V>>)]
+struct StockMapViewIterator<'a, K, V>
+where
+    K: RuntimeType + 'static,
+    V: RuntimeType + 'static,
+    K::Default: Clone + Ord,
+    V::Default: Clone,
+{
+    _owner: ComObject<StockMapView<K, V>>,
+    current: std::sync::RwLock<std::collections::btree_map::Iter<'a, K::Default, V::Default>>,
+}
+
+impl<K, V> IIterator_Impl<IKeyValuePair<K, V>> for StockMapViewIterator_Impl<'_, K, V>
+where
+    K: RuntimeType,
+    V: RuntimeType,
+    K::Default: Clone + Ord,
+    V::Default: Clone,
+{
+    fn Current(&self) -> Result<IKeyValuePair<K, V>> {
+        let mut current = self.current.read().unwrap().clone().peekable();
+
+        if let Some((key, value)) = current.peek() {
+            Ok(ComObject::new(StockKeyValuePair {
+                key: (*key).clone(),
+                value: (*value).clone(),
+            })
+            .into_interface())
+        } else {
+            Err(Error::from(E_BOUNDS))
+        }
+    }
+
+    fn HasCurrent(&self) -> Result<bool> {
+        let mut current = self.current.read().unwrap().clone().peekable();
+        Ok(current.peek().is_some())
+    }
+
+    fn MoveNext(&self) -> Result<bool> {
+        let mut current = self.current.write().unwrap();
+        current.next();
+        Ok(current.clone().peekable().peek().is_some())
+    }
+
+    fn GetMany(&self, pairs: &mut [Option<IKeyValuePair<K, V>>]) -> Result<u32> {
+        let mut current = self.current.write().unwrap();
+        let mut actual = 0;
+
+        for pair in pairs {
+            if let Some((key, value)) = current.next() {
+                *pair = Some(
+                    ComObject::new(StockKeyValuePair {
+                        key: (*key).clone(),
+                        value: (*value).clone(),
+                    })
+                    .into_interface(),
+                );
+                actual += 1;
+            } else {
+                break;
+            }
+        }
+
+        Ok(actual)
+    }
+}
+
+#[implement(IKeyValuePair<K, V>)]
+struct StockKeyValuePair<K, V>
+where
+    K: RuntimeType + 'static,
+    V: RuntimeType + 'static,
+    K::Default: Clone,
+    V::Default: Clone,
+{
+    key: K::Default,
+    value: V::Default,
+}
+
+impl<K, V> IKeyValuePair_Impl<K, V> for StockKeyValuePair_Impl<K, V>
+where
+    K: RuntimeType,
+    V: RuntimeType,
+    K::Default: Clone,
+    V::Default: Clone,
+{
+    fn Key(&self) -> Result<K> {
+        K::from_default(&self.key)
+    }
+
+    fn Value(&self) -> Result<V> {
+        V::from_default(&self.value)
+    }
+}
+
+impl<K, V> From<std::collections::BTreeMap<K::Default, V::Default>> for IMapView<K, V>
+where
+    K: RuntimeType,
+    V: RuntimeType,
+    K::Default: Clone + Ord,
+    V::Default: Clone,
+{
+    fn from(map: std::collections::BTreeMap<K::Default, V::Default>) -> Self {
+        StockMapView { map }.into()
+    }
+}

vendor/windows-collections/src/vector_view.rs

@@ -0,0 +1,131 @@
+use super::*;
+use windows_core::*;
+
+#[implement(IVectorView<T>, IIterable<T>)]
+struct StockVectorView<T>
+where
+    T: RuntimeType + 'static,
+    T::Default: Clone + PartialEq,
+{
+    values: Vec<T::Default>,
+}
+
+impl<T> IIterable_Impl<T> for StockVectorView_Impl<T>
+where
+    T: RuntimeType,
+    T::Default: Clone + PartialEq,
+{
+    fn First(&self) -> Result<IIterator<T>> {
+        Ok(ComObject::new(StockVectorViewIterator {
+            owner: self.to_object(),
+            current: 0.into(),
+        })
+        .into_interface())
+    }
+}
+
+impl<T> IVectorView_Impl<T> for StockVectorView_Impl<T>
+where
+    T: RuntimeType,
+    T::Default: Clone + PartialEq,
+{
+    fn GetAt(&self, index: u32) -> Result<T> {
+        let item = self
+            .values
+            .get(index as usize)
+            .ok_or_else(|| Error::from(E_BOUNDS))?;
+
+        T::from_default(item)
+    }
+
+    fn Size(&self) -> Result<u32> {
+        Ok(self.values.len().try_into()?)
+    }
+
+    fn IndexOf(&self, value: Ref<T>, result: &mut u32) -> Result<bool> {
+        match self.values.iter().position(|element| element == &*value) {
+            Some(index) => {
+                *result = index as u32;
+                Ok(true)
+            }
+            None => Ok(false),
+        }
+    }
+
+    fn GetMany(&self, current: u32, values: &mut [T::Default]) -> Result<u32> {
+        let current = current as usize;
+
+        if current >= self.values.len() {
+            return Ok(0);
+        }
+
+        let actual = std::cmp::min(self.values.len() - current, values.len());
+        let (values, _) = values.split_at_mut(actual);
+        values.clone_from_slice(&self.values[current..current + actual]);
+        Ok(actual as u32)
+    }
+}
+
+#[implement(IIterator<T>)]
+struct StockVectorViewIterator<T>
+where
+    T: RuntimeType + 'static,
+    T::Default: Clone + PartialEq,
+{
+    owner: ComObject<StockVectorView<T>>,
+    current: std::sync::atomic::AtomicUsize,
+}
+
+impl<T> IIterator_Impl<T> for StockVectorViewIterator_Impl<T>
+where
+    T: RuntimeType,
+    T::Default: Clone + PartialEq,
+{
+    fn Current(&self) -> Result<T> {
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+
+        if let Some(item) = self.owner.values.get(current) {
+            T::from_default(item)
+        } else {
+            Err(Error::from(E_BOUNDS))
+        }
+    }
+
+    fn HasCurrent(&self) -> Result<bool> {
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+        Ok(self.owner.values.len() > current)
+    }
+
+    fn MoveNext(&self) -> Result<bool> {
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+
+        if current < self.owner.values.len() {
+            self.current
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        }
+
+        Ok(self.owner.values.len() > current + 1)
+    }
+
+    fn GetMany(&self, values: &mut [T::Default]) -> Result<u32> {
+        let current = self.current.load(std::sync::atomic::Ordering::Relaxed);
+        let actual = std::cmp::min(self.owner.values.len() - current, values.len());
+        let (values, _) = values.split_at_mut(actual);
+        values.clone_from_slice(&self.owner.values[current..current + actual]);
+
+        self.current
+            .fetch_add(actual, std::sync::atomic::Ordering::Relaxed);
+
+        Ok(actual as u32)
+    }
+}
+
+impl<T> From<Vec<T::Default>> for IVectorView<T>
+where
+    T: RuntimeType,
+    T::Default: Clone + PartialEq,
+{
+    fn from(values: Vec<T::Default>) -> Self {
+        ComObject::new(StockVectorView { values }).into_interface()
+    }
+}