/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at
http://mozilla.org/MPL/2.0/. */
use nserror::{nsresult, NS_ERROR_CANNOT_CONVERT_DATA, NS_OK};
use nsstring::nsString;
use xpcom::{
getter_addrefs,
interfaces::{nsIProperty, nsIPropertyBag, nsIWritablePropertyBag},
RefPtr, XpCom,
};
use crate::{NsIVariantExt, VariantType};
extern "C" {
fn NS_NewHashPropertyBag(bag: *mut *const nsIWritablePropertyBag);
}
/// A hash property bag backed by storage variant values.
pub struct HashPropertyBag(RefPtr<nsIWritablePropertyBag>);
// This is safe as long as our `nsIWritablePropertyBag` is an instance of
// `mozilla::nsHashPropertyBag`, which is atomically reference counted, and
// all properties are backed by `Storage*Variant`s, all of which are
// thread-safe.
unsafe impl Send for HashPropertyBag {}
unsafe impl Sync for HashPropertyBag {}
impl Default for HashPropertyBag {
fn default() -> HashPropertyBag {
// This is safe to unwrap because `NS_NewHashPropertyBag` is infallible.
let bag = getter_addrefs(|p| {
unsafe { NS_NewHashPropertyBag(p) };
NS_OK
})
.unwrap();
HashPropertyBag(bag)
}
}
impl HashPropertyBag {
/// Creates an empty property bag.
#[inline]
pub fn new() -> Self {
Self::default()
}
/// Creates a property bag from an instance of `nsIPropertyBag`, cloning its
/// contents. The `source` bag can only contain primitive values for which
/// the `VariantType` trait is implemented. Attempting to clone a bag with
/// unsupported types, such as arrays, interface pointers, and `jsval`s,
/// fails with `NS_ERROR_CANNOT_CONVERT_DATA`.
///
/// `clone_from_bag` can be used to clone a thread-unsafe `nsIPropertyBag`,
/// like one passed from JavaScript via XPConnect, into one that can be
/// shared across threads.
pub fn clone_from_bag(source: &nsIPropertyBag) -> Result<Self, nsresult> {
let enumerator = getter_addrefs(|p| unsafe { source.GetEnumerator(p) })?;
let b = HashPropertyBag::new();
while {
let mut has_more = false;
unsafe { enumerator.HasMoreElements(&mut has_more) }.to_result()?;
has_more
} {
let element = getter_addrefs(|p| unsafe { enumerator.GetNext(p) })?;
let property = element
.query_interface::<nsIProperty>()
.ok_or(NS_ERROR_CANNOT_CONVERT_DATA)?;
let mut name = nsString::new();
unsafe { property.GetName(&mut *name) }.to_result()?;
let value = getter_addrefs(|p| unsafe { property.GetValue(p) })?;
unsafe { b.0.SetProperty(&*name, value.try_clone()?.coerce()) }.to_result()?;
}
Ok(b)
}
/// Returns the value for a property name. Fails with `NS_ERROR_FAILURE`
/// if the property doesn't exist, or `NS_ERROR_CANNOT_CONVERT_DATA` if the
/// property exists, but is not of the value type `V`.
pub fn get<K, V>(&self, name: K) -> Result<V, nsresult>
where
K: AsRef<str>,
V: VariantType,
{
getter_addrefs(|p| unsafe { self.0.GetProperty(&*nsString::from(name.as_ref()), p) })
.and_then(|v| V::from_variant(v.coerce()))
}
/// Returns the value for a property name, or the default if not set or
/// not of the value type `V`.
#[inline]
pub fn get_or_default<K, V>(&self, name: K) -> V
where
K: AsRef<str>,
V: VariantType + Default,
{
self.get(name).unwrap_or_default()
}
/// Sets a property with the name to the value, overwriting any previous
/// value.
pub fn set<K, V>(&mut self, name: K, value: V)
where
K: AsRef<str>,
V: VariantType,
{
let v = value.into_variant();
unsafe {
// This is safe to unwrap because
// `nsHashPropertyBagBase::SetProperty` only returns an error if `v`
// is a null pointer.
self.0
.SetProperty(&*nsString::from(name.as_ref()), v.coerce())
.to_result()
.unwrap()
}
}
/// Deletes a property with the name. Returns `true` if the property
/// was previously in the bag, `false` if not.
pub fn delete(&mut self, name: impl AsRef<str>) -> bool {
unsafe {
self.0
.DeleteProperty(&*nsString::from(name.as_ref()))
.to_result()
.is_ok()
}
}
/// Returns a reference to the backing `nsIWritablePropertyBag`.
#[inline]
pub fn bag(&self) -> &nsIWritablePropertyBag {
&self.0
}
}
