Deque

libs/Forc.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
+  "deque",
   "fixed_point",
   "merkle_proof",
   "nft",

libs/deque/.gitignore

@@ -0,0 +1,2 @@
+out
+target

libs/deque/Forc.toml

@@ -0,0 +1,7 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "deque"
+
+[dependencies]

libs/deque/src/main.sw

@@ -0,0 +1,75 @@
+library;
+//! The `Deque` type corresponds to the same called data structure.
+//! A Deque is defined as a linear data structure that allows insertion and removal of elements from both ends.
+
+pub struct Deque<T> {
+    front: Vec<T>,
+    back: Vec<T>,
+}
+
+impl<T> Deque<T> {
+    /// Creates a new, empty deque.
+    pub fn new() -> Self {
+        Self {
+            front: Vec::new(),
+            back: Vec::new(),
+        }
+    }
+
+    /// Creates a new, empty deque with the specified capacity.
+    pub fn with_capacity(capacity: u64) -> Self {
+        Self {
+            front: Vec::with_capacity(capacity),
+            back: Vec::with_capacity(capacity),
+        }
+    }
+
+    /// Appends an element to the back of the deque.
+    pub fn push_back(ref mut self, value: T) {
+        self.back.push(value);
+    }
+
+    /// Inserts an element at the front of the deque.
+    pub fn push_front(ref mut self, value: T) {
+        self.front.push(value);
+    }
+
+    pub fn pop_front(ref mut self) -> Option<T> {
+        if self.front.is_empty() {
+            if !self.back.is_empty() {
+                self.front.push(self.back.remove(0))
+            }
+        }
+        self.front.pop()
+    }
+
+    pub fn pop_back(ref mut self) -> Option<T> {
+        if self.back.is_empty() {
+            if !self.front.is_empty() {
+                self.back.push(self.front.remove(0))
+            }
+        }
+        self.back.pop()
+    }
+
+    /// Returns the number of elements in the deque.
+    pub fn len(self) -> u64 {
+        self.front.len() + self.back.len()
+    }
+
+    /// Returns `true` if the deque is empty.
+    pub fn is_empty(self) -> bool {
+        self.front.is_empty() && self.back.is_empty()
+    }
+
+    /// Removes all elements from the deque.
+    pub fn clear(self) {
+        self.front.clear();
+        self.back.clear();
+    }
+
+    /// Returns the maximum number of elements the deque can hold without reallocating.
+    pub fn capacity(self) -> u64 {
+        self.front.capacity() + self.back.capacity()
+    }
+}

tests/src/deque/.gitignore

@@ -0,0 +1,2 @@
+out
+target

tests/src/deque/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "deque_test"
+
+[dependencies]
+deque = { path = "../../../libs/deque" }

tests/src/deque/mod.rs

@@ -0,0 +1 @@
+mod tests;

tests/src/deque/src/main.sw

@@ -0,0 +1,37 @@
+script;
+
+use deque::Deque;
+use std::assert::assert;
+
+fn main() -> bool {
+    let mut deque_push_front = Deque::new();
+    deque_push_front.push_front(1);
+    deque_push_front.push_front(2);
+    deque_push_front.push_front(3);
+
+    assert(deque_push_front.pop_front().unwrap() == 3);
+    assert(deque_push_front.pop_front().unwrap() == 2);
+    assert(deque_push_front.pop_front().unwrap() == 1);
+    assert(deque_push_front.pop_front().is_none());
+
+    let mut deque_push_back = Deque::new();
+    deque_push_back.push_back(1);
+    deque_push_back.push_back(2);
+    deque_push_back.push_back(3);
+
+    assert(deque_push_back.pop_front().unwrap() == 1);
+    assert(deque_push_back.pop_front().unwrap() == 2);
+    assert(deque_push_back.pop_front().unwrap() == 3);
+    assert(deque_push_back.pop_front().is_none());
+
+    let mut deque = Deque::new();
+    assert(deque.len() == 0);
+    deque.push_front(1);
+    assert(deque.len() == 1);
+    deque.push_front(2);
+    assert(deque.len() == 2);
+    let _ = deque.pop_front();
+    assert(deque.len() == 1);
+
+    true
+}

tests/src/deque/tests/mod.rs

@@ -0,0 +1,21 @@
+use fuels::prelude::{abigen, launch_provider_and_get_wallet};
+
+abigen!(Script(
+    name = "TestDeque",
+    abi = "src/deque/out/debug/deque_test-abi.json"
+),);
+
+mod success {
+
+    use super::*;
+
+    #[tokio::test]
+    async fn runs_queue_test_script() {
+        let path_to_bin = "src/deque/out/debug/deque_test.bin";
+        let wallet = launch_provider_and_get_wallet().await;
+
+        let instance = TestDeque::new(wallet, path_to_bin);
+
+        let _result = instance.main().call().await;
+    }
+}