WIP: task stack

src/buffer.rs

···
+use std::{
+    collections::BinaryHeap,
+    sync::{Condvar, Mutex},
+};
+struct PooledHandle<'a, T: Ord + Default> {
+    parent: &'a Pool<T>,
+    item: Option<T>,
+}
+
+struct Pool<T: Ord + Default>(Mutex<BinaryHeap<T>>, Condvar);
+
+impl<'a, T: Ord + Default> Pool<T> {
+    pub fn give(&self, item: T) {
+        self.0.lock().expect("Poisoned lock").push(item)
+    }
+
+    /// Retrieves
+    pub fn take(&self) -> Option<T> {
+        self.0.lock().expect("Poisoned lock").pop()
+    }
+
+    pub fn lease(&self) -> PooledHandle<'a, T> {
+        let guard = self.0.lock().expect("Poisoned lock");
+        match guard.pop() {
+            Some(item) => PooledHandle {
+                parent: self,
+                item: Some(item),
+            },
+            None => {
+                let mut item = None;
+                while item.is_none() {
+                    let guard = self.1.wait(guard).expect("Poisoned lock");
+                    item = guard.pop();
+                }
+
+            },
+        }
+    }
+}
+
+impl<T: Ord> AsRef<T> for PooledHandle<'_, T> {
+    fn as_ref(&self) -> &T {
+        &self.item
+    }
+}
+
+impl<T: Ord> Drop for PooledHandle<'_, T> {
+    fn drop(&mut self) {
+        self.parent.give(self.item)
+    }
+}

src/main.rs

···
 mod workspace;
 mod stack;
 mod util;
+mod buffer;
 use std::path::PathBuf;
 use std::{env::current_dir, io::Read};
 use workspace::Workspace;

src/stack.rs

···
 
 use crate::errors::{Error, Result};
 use crate::util;
-use std::io::{self, BufRead};
-use std::num::ParseIntError;
-use std::{fs::File, io::Read, path::PathBuf};
+use std::io::{self, BufRead, Read};
+use std::{fs::File, path::PathBuf};
 
 use nix::fcntl::{Flock, FlockArg};
 
-use crate::workspace::Id;
-
-const INDEXFILE: &str = "index";
-const TITLECACHEFILE: &str = "cache";
+use crate::workspace::{Id, Workspace};
 
 struct StackItem {
     id: Id,
···
 }
 
 impl StackItem {
-    fn from_reader(reader: &mut impl BufRead) -> Result<Self> {
+    fn from_reader(workspace_path: &PathBuf, reader: &mut impl BufRead) -> Result<Self> {
         let mut buf = String::new();
         reader.read_line(&mut buf)?;
         if buf.is_empty() {
···
             )));
         }
         let (id, next) = Self::parse(&buf)?;
+        let title = util::flopen(workspace_path.join("tasks").join(id), mode)
         todo!();
     }
 
···
 }
 
 impl TaskStack {
-    fn from_tskdir(path: &PathBuf) -> Self {
-        let index = util::flopen(&path.join(INDEXFILE), FlockArg::LockExclusive);
-        let cache = util::flopen(&path.join(TITLECACHEFILE), FlockArg::LockShared);
-
+    fn from_tskdir(path: &PathBuf) -> Result<Self> {
         todo!()
     }
 }

src/util.rs

···
 
 use nix::fcntl::{Flock, FlockArg};
 
-pub fn flopen(path: &PathBuf, mode: FlockArg) -> Result<Flock<File>> {
+pub fn flopen(path: PathBuf, mode: FlockArg) -> Result<Flock<File>> {
     let file = OpenOptions::new()
         .read(true)
         .write(true)

src/workspace.rs

···
 use nix::fcntl::{Flock, FlockArg};
 
 use crate::errors::{Error, Result};
+use crate::stack::TaskStack;
 use crate::util;
 use std::fs::File;
 use std::io::{Read, Seek};
···
 use std::str::FromStr;
 use std::{fs::OpenOptions, io::Write};
 
+const INDEXFILE: &str = "index";
+const TITLECACHEFILE: &str = "cache";
 /// A unique identifier for a task. When referenced in text, it is prefixed with `tsk-`.
 pub struct Id(u32);
 
···
     }
 
     pub fn next_id(&self) -> Result<Id> {
-        let mut file = util::flopen(&self.path.join("next"), FlockArg::LockExclusive)?;
+        let mut file = util::flopen(self.path.join("next"), FlockArg::LockExclusive)?;
         let mut buf = String::new();
         file.read_to_string(&mut buf)?;
         let id = buf.trim().parse::<u32>()?;
···
         // TODO: we could improperly increment the id if the task is not written to disk/errors
         let id = self.next_id()?;
         let mut file = util::flopen(
-            &self.path.join("tasks").join(format!("tsk-{}.tsk", id.0)),
+            self.path.join("tasks").join(format!("tsk-{}.tsk", id.0)),
             FlockArg::LockExclusive,
         )?;
         file.write_all(format!("{title}\n\n{body}").as_bytes())?;
···
             body,
             file,
         })
+    }
+
+    fn read_stack(&self) -> Result<TaskStack> {
+        let mut index = String::new();
+        let mut cache = String::new();
+        let mut index_file = util::flopen(self.path.join(INDEXFILE), FlockArg::LockExclusive)?;
+        let mut cache_file = util::flopen(self.path.join(TITLECACHEFILE), FlockArg::LockShared)?;
+        index_file.read_to_string(&mut index)?;
+        for line in index.lines() {
+            
+        }
+
+        todo!();
     }
 }