cry/nixide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

internally pass EvalState via Rc<RefCell<NonNull<sys::EvalState>>>

Browse source
This commit is contained in:
do butterflies cry? 2026-03-30 15:05:20 +10:00
parent 18fcc93c36
commit c5c3f6c8d4
Signed by: cry
GPG key ID: F68745A836CA0412
16 changed files with 127 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

46
nixide/src/expr/eval_state.rs
View file

@ -1,7 +1,8 @@
use std::ffi::{CString, c_void};
use std::cell::RefCell;
use std::ptr::NonNull;
use std::rc::Rc;
use crate::errors::new_nixide_error;
use crate::stdext::AsCPtr as _;
use super::Value;
use crate::errors::ErrorContext;
@ -15,9 +16,9 @@ use crate::{NixideResult, Store};
/// This provides the main interface for evaluating Nix expressions
/// and creating values.
pub struct EvalState {
inner: NonNull<sys::EvalState>,
inner: Rc<RefCell<NonNull<sys::EvalState>>>,
store: Store,
store: Rc<RefCell<Store>>,
}
// impl Clone for EvalState {
@ -39,31 +40,37 @@ pub struct EvalState {
impl AsInnerPtr<sys::EvalState> for EvalState {
#[inline]
unsafe fn as_ptr(&self) -> *mut sys::EvalState {
self.inner.as_ptr()
self.inner.borrow().as_ptr()
}
#[inline]
unsafe fn as_ref(&self) -> &sys::EvalState {
unsafe { self.inner.as_ref() }
unsafe { self.inner.borrow().as_ref() }
}
#[inline]
unsafe fn as_mut(&mut self) -> &mut sys::EvalState {
unsafe { self.inner.as_mut() }
unsafe { self.inner.borrow_mut().as_mut() }
}
}
impl EvalState {
/// Construct a new EvalState directly from its attributes
///
pub(super) fn new(inner: NonNull<sys::EvalState>, store: &Store) -> Self {
pub(super) fn from(inner: NonNull<sys::EvalState>, store: Rc<RefCell<Store>>) -> Self {
Self {
inner,
store: store.clone(),
inner: Rc::new(RefCell::new(inner)),
store,
}
}
pub fn store_ref(&self) -> &Store {
#[inline]
pub fn inner_ref(&self) -> &Rc<RefCell<NonNull<sys::EvalState>>> {
&self.inner
}
#[inline]
pub fn store_ref(&self) -> &Rc<RefCell<Store>> {
&self.store
}
@ -77,9 +84,10 @@ impl EvalState {
/// # Errors
///
/// Returns an error if evaluation fails.
///
pub fn interpret(&self, expr: &str, path: &str) -> NixideResult<Value> {
let expr_c = CString::new(expr).or(Err(new_nixide_error!(StringNulByte)))?;
let path_c = CString::new(path).or(Err(new_nixide_error!(StringNulByte)))?;
let expr = expr.as_c_ptr()?;
let path = path.as_c_ptr()?;
// Allocate value for result
// XXX: TODO: create a method for this (``)
@ -90,13 +98,7 @@ impl EvalState {
// Evaluate expression
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_expr_eval_from_string(
ctx.as_ptr(),
self.as_ptr(),
expr_c.as_ptr(),
path_c.as_ptr(),
value.as_ptr(),
);
sys::nix_expr_eval_from_string(ctx.as_ptr(), self.as_ptr(), expr, path, value.as_ptr());
value
})
.map(|ptr| Value::from((ptr, self)))
@ -110,7 +112,3 @@ impl Drop for EvalState {
}
}
}
// SAFETY: EvalState can be shared between threads
unsafe impl Send for EvalState {}
unsafe impl Sync for EvalState {}

24
nixide/src/expr/eval_state_builder.rs
View file

@ -1,5 +1,7 @@
use std::ffi::{CString, c_char, c_void};
use std::cell::RefCell;
use std::ffi::{CString, c_char};
use std::ptr::{self, NonNull};
use std::rc::Rc;
use super::EvalState;
#[cfg(feature = "flakes")]
@ -16,8 +18,8 @@ use crate::util::{panic_issue_call_failed, wrap};
/// the evaluation state.
///
pub struct EvalStateBuilder {
inner: NonNull<sys::nix_eval_state_builder>,
store: Store,
inner: Rc<RefCell<NonNull<sys::nix_eval_state_builder>>>,
store: Rc<RefCell<Store>>,
}
// impl Clone for EvalStateBuilder {
@ -39,17 +41,17 @@ pub struct EvalStateBuilder {
impl AsInnerPtr<sys::nix_eval_state_builder> for EvalStateBuilder {
#[inline]
unsafe fn as_ptr(&self) -> *mut sys::nix_eval_state_builder {
self.inner.as_ptr()
self.inner.borrow().as_ptr()
}
#[inline]
unsafe fn as_ref(&self) -> &sys::nix_eval_state_builder {
unsafe { self.inner.as_ref() }
unsafe { self.inner.borrow().as_ref() }
}
#[inline]
unsafe fn as_mut(&mut self) -> &mut sys::nix_eval_state_builder {
unsafe { self.inner.as_mut() }
unsafe { self.inner.borrow_mut().as_mut() }
}
}
@ -64,14 +66,14 @@ impl EvalStateBuilder {
///
/// Returns an error if the builder cannot be created.
///
pub fn new(store: &Store) -> NixideResult<Self> {
pub fn new(store: Rc<RefCell<Store>>) -> NixideResult<Self> {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_eval_state_builder_new(ctx.as_ptr(), store.as_ptr())
sys::nix_eval_state_builder_new(ctx.as_ptr(), store.borrow().as_ptr())
})?;
Ok(EvalStateBuilder {
inner,
store: store.clone(),
inner: Rc::new(RefCell::new(inner)),
store,
})
}
@ -87,7 +89,7 @@ impl EvalStateBuilder {
sys::nix_eval_state_build(ctx.as_ptr(), self.as_ptr())
})?;
Ok(EvalState::new(inner, &self.store))
Ok(EvalState::from(inner, self.store.clone()))
}
// XXX: TODO: use `flakes()` instead

37
nixide/src/expr/realised_string.rs
View file

@ -1,15 +1,15 @@
use std::cell::RefCell;
use std::ffi::{c_char, c_void};
use std::ffi::c_char;
use std::ptr::NonNull;
use crate::errors::ErrorContext;
use crate::expr::values::NixString;
use crate::stdext::CCharPtrExt;
use crate::sys;
use crate::util::LazyArray;
use crate::util::wrappers::AsInnerPtr;
use crate::util::{panic_issue_call_failed, wrap};
use crate::{EvalState, NixideResult, StorePath};
use crate::{Store, sys};
pub struct RealisedString<'a> {
inner: RefCell<NonNull<sys::nix_realised_string>>,
@ -17,23 +17,6 @@ pub struct RealisedString<'a> {
pub children: LazyArray<StorePath, Box<dyn Fn(usize) -> StorePath + 'a>>,
}
// impl<'a> Clone for RealisedString<'a> {
// fn clone(&self) -> Self {
// let inner = self.inner.clone();
// wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
// sys::nix_gc_incref(ctx.as_ptr(), self.as_ptr() as *mut c_void);
// })
// .unwrap();
// Self {
// inner,
// path: self.path.clone(),
// children: self.children,
// }
// }
// }
impl<'a> AsInnerPtr<sys::nix_realised_string> for RealisedString<'a> {
#[inline]
unsafe fn as_ptr(&self) -> *mut sys::nix_realised_string {
@ -63,7 +46,7 @@ impl<'a> RealisedString<'a> {
/// Realise a string context.
///
/// This will
/// - realise the store paths referenced by the string's context, and
/// - realise the store paths referenced by the string's content, and
/// - perform the replacement of placeholders.
/// - create temporary garbage collection roots for the store paths, for
/// the lifetime of the current process.
@ -77,9 +60,6 @@ impl<'a> RealisedString<'a> {
/// You should set this to true when this call is part of a primop.
/// You should set this to false when building for your application's purpose.
///
/// # Returns
///
/// NULL if failed, or a new nix_realised_string, which must be freed with nix_realised_string_free
pub fn new(value: &NixString, state: &'a EvalState) -> NixideResult<RealisedString<'a>> {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_string_realise(
@ -89,21 +69,20 @@ impl<'a> RealisedString<'a> {
false, // don't copy more
)
})?;
let cell = RefCell::new(inner);
let size = unsafe { sys::nix_realised_string_get_store_path_count(inner.as_ptr()) };
Ok(Self {
inner: cell,
path: Self::parse_path(inner.as_ptr(), state),
inner: RefCell::new(inner),
path: Self::parse_path(inner.as_ptr(), &state.store_ref().borrow()),
children: LazyArray::new(
size,
Box::new(|_| StorePath::fake_path(state.store_ref()).unwrap()),
Box::new(|_| StorePath::fake_path(&state.store_ref().borrow()).unwrap()),
),
})
}
fn parse_path(realised_string: *mut sys::nix_realised_string, state: &EvalState) -> StorePath {
fn parse_path(realised_string: *mut sys::nix_realised_string, store: &Store) -> StorePath {
let buffer_ptr = unsafe { sys::nix_realised_string_get_buffer_start(realised_string) };
let buffer_size = unsafe { sys::nix_realised_string_get_buffer_size(realised_string) };
@ -115,7 +94,7 @@ impl<'a> RealisedString<'a> {
err
)
});
StorePath::parse(state.store_ref(), &path_str).unwrap_or_else(|err| {
StorePath::parse(store, &path_str).unwrap_or_else(|err| {
panic_issue_call_failed!(
"`sys::nix_realised_string_get_buffer_(start|size)` invalid store path ({})",
err

15
nixide/src/expr/tests.rs
View file

@ -1,5 +1,3 @@
use std::rc::Rc;
use serial_test::serial;
use super::{EvalStateBuilder, Value};
@ -8,19 +6,18 @@ use crate::Store;
#[test]
#[serial]
fn test_eval_state_builder() {
let store = Rc::new(Store::default().expect("Failed to open store"));
let _state = EvalStateBuilder::new(&store)
let store = Store::default().expect("Failed to open store");
let _state = EvalStateBuilder::new(store.clone())
.expect("Failed to create builder")
.build()
.expect("Failed to build state");
// State should be dropped automatically
}
#[test]
#[serial]
fn test_simple_evaluation() {
let store = Rc::new(Store::default().expect("Failed to open store"));
let state = EvalStateBuilder::new(&store)
let store = Store::default().expect("Failed to open store");
let state = EvalStateBuilder::new(store.clone())
.expect("Failed to create builder")
.build()
.expect("Failed to build state");
@ -41,7 +38,7 @@ fn test_simple_evaluation() {
#[serial]
fn test_value_types() {
let store = Store::default().expect("Failed to open store");
let state = EvalStateBuilder::new(&store)
let state = EvalStateBuilder::new(store.clone())
.expect("Failed to create builder")
.build()
.expect("Failed to build state");
@ -84,7 +81,7 @@ fn test_value_types() {
#[serial]
fn test_value_formatting() {
let store = Store::default().expect("Failed to open store");
let state = EvalStateBuilder::new(&store)
let state = EvalStateBuilder::new(store.clone())
.expect("Failed to create builder")
.build()
.expect("Failed to build state");

21
nixide/src/expr/values/attrs.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::{self, NonNull};
use std::rc::Rc;
use super::{NixThunk, NixValue, Value};
use crate::errors::{ErrorContext, NixideError};
@ -11,7 +13,7 @@ use crate::{EvalState, NixError};
pub struct NixAttrs {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
len: u32,
}
@ -84,7 +86,7 @@ impl NixValue for NixAttrs {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
len,
}
}
@ -107,7 +109,7 @@ impl NixAttrs {
sys::nix_get_attr_byidx(
ctx.as_ptr(),
self.as_ptr(),
self.state.as_ptr(),
self.state.borrow().as_ptr(),
index,
name_ptr,
)
@ -134,7 +136,7 @@ impl NixAttrs {
sys::nix_get_attr_byidx_lazy(
ctx.as_ptr(),
self.as_ptr(),
self.state.as_ptr(),
self.state.borrow().as_ptr(),
index,
name_ptr,
)
@ -156,7 +158,12 @@ impl NixAttrs {
}
let name_ptr = wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_get_attr_name_byidx(ctx.as_ptr(), self.as_ptr(), self.state.as_ptr(), index)
sys::nix_get_attr_name_byidx(
ctx.as_ptr(),
self.as_ptr(),
self.state.borrow().as_ptr(),
index,
)
})
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err));
@ -175,7 +182,7 @@ impl NixAttrs {
sys::nix_get_attr_byname(
ctx.as_ptr(),
self.as_ptr(),
self.state.as_ptr(),
self.state.borrow().as_ptr(),
name.as_ref()
.into_c_ptr()
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err)),
@ -201,7 +208,7 @@ impl NixAttrs {
sys::nix_get_attr_byname_lazy(
ctx.as_ptr(),
self.as_ptr(),
self.state.as_ptr(),
self.state.borrow().as_ptr(),
name.as_ref()
.into_c_ptr()
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err)),

6
nixide/src/expr/values/bool.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::NixValue;
use crate::errors::ErrorContext;
@ -10,7 +12,7 @@ use crate::{EvalState, sys};
pub struct NixBool {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
value: bool,
}
@ -85,7 +87,7 @@ impl NixValue for NixBool {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
value,
}
}

6
nixide/src/expr/values/float.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::NixValue;
use crate::EvalState;
@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap};
pub struct NixFloat {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
value: f64,
}
@ -85,7 +87,7 @@ impl NixValue for NixFloat {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
value,
}
}

14
nixide/src/expr/values/function.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::{NixValue, Value};
use crate::errors::ErrorContext;
@ -10,7 +12,7 @@ use crate::{EvalState, sys};
pub struct NixFunction {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
}
impl Clone for NixFunction {
@ -76,7 +78,7 @@ impl NixValue for NixFunction {
fn from(inner: NonNull<sys::nix_value>, state: &EvalState) -> Self {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
}
}
}
@ -87,14 +89,14 @@ impl NixFunction {
T: NixValue,
{
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_alloc_value(ctx.as_ptr(), self.state.as_ptr())
sys::nix_alloc_value(ctx.as_ptr(), self.state.borrow().as_ptr())
})
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err));
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_value_call(
ctx.as_ptr(),
self.state.as_ptr(),
self.state.borrow().as_ptr(),
self.as_ptr(),
arg.as_ptr(),
inner.as_ptr(),
@ -110,14 +112,14 @@ impl NixFunction {
T: NixValue,
{
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_alloc_value(ctx.as_ptr(), self.state.as_ptr())
sys::nix_alloc_value(ctx.as_ptr(), self.state.borrow().as_ptr())
})
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err));
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_value_call_multi(
ctx.as_ptr(),
self.state.as_ptr(),
self.state.borrow().as_ptr(),
self.as_ptr(),
args.len(),
args.into_c_array(),

6
nixide/src/expr/values/int.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::NixValue;
use crate::EvalState;
@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap};
pub struct NixInt {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
value: i64,
}
@ -83,7 +85,7 @@ impl NixValue for NixInt {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
value,
}
}

20
nixide/src/expr/values/list.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::{NixThunk, NixValue, Value};
use crate::EvalState;
@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap};
pub struct NixList {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
}
impl Clone for NixList {
@ -76,7 +78,7 @@ impl NixValue for NixList {
fn from(inner: NonNull<sys::nix_value>, state: &EvalState) -> Self {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
}
}
}
@ -116,7 +118,12 @@ impl NixList {
pub fn get(&self, index: u32) -> Value {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_get_list_byidx(ctx.as_ptr(), self.as_ptr(), self.state.as_ptr(), index)
sys::nix_get_list_byidx(
ctx.as_ptr(),
self.as_ptr(),
self.state.borrow().as_ptr(),
index,
)
})
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err));
@ -125,7 +132,12 @@ impl NixList {
pub fn get_lazy(&self, index: u32) -> NixThunk {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_get_list_byidx_lazy(ctx.as_ptr(), self.as_ptr(), self.state.as_ptr(), index)
sys::nix_get_list_byidx_lazy(
ctx.as_ptr(),
self.as_ptr(),
self.state.borrow().as_ptr(),
index,
)
})
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err));

6
nixide/src/expr/values/null.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::NixValue;
use crate::EvalState;
@ -10,7 +12,7 @@ use crate::util::wrappers::AsInnerPtr;
pub struct NixNull {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
}
impl Clone for NixNull {
@ -76,7 +78,7 @@ impl NixValue for NixNull {
fn from(inner: NonNull<sys::nix_value>, state: &EvalState) -> Self {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
}
}
}

6
nixide/src/expr/values/path.rs
View file

@ -1,6 +1,8 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::path::PathBuf;
use std::ptr::NonNull;
use std::rc::Rc;
use super::NixValue;
use crate::errors::ErrorContext;
@ -12,7 +14,7 @@ use crate::{EvalState, sys};
pub struct NixPath {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
value: PathBuf,
}
@ -87,7 +89,7 @@ impl NixValue for NixPath {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
value,
}
}

7
nixide/src/expr/values/string.rs
View file

@ -1,5 +1,8 @@
use std::cell::RefCell;
use std::ffi::c_void;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::NixValue;
use crate::errors::ErrorContext;
@ -10,7 +13,7 @@ use crate::{EvalState, sys};
pub struct NixString {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
value: String,
}
@ -90,7 +93,7 @@ impl NixValue for NixString {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
value,
}
}

12
nixide/src/expr/values/thunk.rs
View file

@ -1,5 +1,7 @@
use std::cell::RefCell;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
use std::ptr::NonNull;
use std::rc::Rc;
use super::{NixValue, Value};
use crate::EvalState;
@ -10,7 +12,7 @@ use crate::util::{panic_issue_call_failed, wrap};
pub struct NixThunk {
inner: NonNull<sys::nix_value>,
state: EvalState,
state: Rc<RefCell<NonNull<sys::EvalState>>>,
}
impl Clone for NixThunk {
@ -76,7 +78,7 @@ impl NixValue for NixThunk {
fn from(inner: NonNull<sys::nix_value>, state: &EvalState) -> Self {
Self {
inner,
state: state.clone(),
state: state.inner_ref().clone(),
}
}
}
@ -84,7 +86,11 @@ impl NixValue for NixThunk {
impl NixThunk {
pub fn eval(self) -> Value {
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
sys::nix_value_force(ctx.as_ptr(), self.state.as_ptr(), self.inner.as_ptr())
sys::nix_value_force(
ctx.as_ptr(),
self.state.borrow().as_ptr(),
self.inner.as_ptr(),
)
})
.unwrap_or_else(|err| panic_issue_call_failed!("{}", err));

1
nixide/src/flake/fetchers_settings.rs
View file

@ -1,4 +1,3 @@
use std::ffi::c_void;
use std::ptr::NonNull;
use crate::NixideResult;

10
nixide/src/store/mod.rs
View file

@ -7,9 +7,11 @@ mod tests;
mod path;
pub use path::*;
use std::cell::RefCell;
use std::ffi::{c_char, c_void};
use std::path::PathBuf;
use std::ptr::{NonNull, null, null_mut};
use std::rc::Rc;
use crate::NixideResult;
use crate::errors::ErrorContext;
@ -68,24 +70,24 @@ impl Store {
///
/// Returns an error if the store cannot be opened.
///
pub fn open(uri: &str) -> NixideResult<Self> {
pub fn open(uri: &str) -> NixideResult<Rc<RefCell<Self>>> {
Self::open_ptr(uri.as_c_ptr()?)
}
/// Opens a connection to the default Nix store.
///
pub fn default() -> NixideResult<Self> {
pub fn default() -> NixideResult<Rc<RefCell<Self>>> {
Self::open_ptr(null())
}
#[inline]
fn open_ptr(uri_ptr: *const c_char) -> NixideResult<Self> {
fn open_ptr(uri_ptr: *const c_char) -> NixideResult<Rc<RefCell<Self>>> {
let inner = wrap::nix_ptr_fn!(|ctx: &ErrorContext| unsafe {
// XXX: TODO: allow args to be parsed instead of just `null_mut`
sys::nix_store_open(ctx.as_ptr(), uri_ptr, null_mut())
})?;
Ok(Store { inner })
Ok(Rc::new(RefCell::new(Store { inner })))
}
/// Realize a store path.