rename fields and struct

src/lib.rs

@@ -28,15 +28,15 @@ impl<'a> Record<'a> {
     }
 }
 
-/// Ressource used by mrecordlog
+/// Resource used by mrecordlog
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct RessourceUsage {
+pub struct ResourceUsage {
     /// Actual size of the memory used
-    pub memory_size: usize,
+    pub memory_used_bytes: usize,
     /// Capacity allocated, a part of which may be unused right now
-    pub memory_capacity: usize,
+    pub memory_allocated_bytes: usize,
     /// Disk size used
-    pub disk_size: usize,
+    pub disk_used_bytes: usize,
 }
 
 #[cfg(test)]

src/mem/queues.rs

@@ -6,7 +6,7 @@ use tracing::{info, warn};
 use crate::error::{AlreadyExists, AppendError, MissingQueue};
 use crate::mem::MemQueue;
 use crate::rolling::FileNumber;
-use crate::{Record};
+use crate::Record;
 
 #[derive(Default)]
 pub(crate) struct MemQueues {

src/multi_record_log.rs

@@ -13,7 +13,7 @@ use crate::mem::MemQueue;
 use crate::record::{MultiPlexedRecord, MultiRecord};
 use crate::recordlog::RecordWriter;
 use crate::rolling::RollingWriter;
-use crate::{mem, RessourceUsage, Record};
+use crate::{mem, Record, ResourceUsage};
 
 pub struct MultiRecordLog {
     record_log_writer: crate::recordlog::RecordWriter<RollingWriter>,
@@ -355,12 +355,14 @@ impl MultiRecordLog {
         self.in_mem_queues.last_record(queue)
     }
 
-    /// Return the ammount of memory and disk space used by mrecordlog.
-    pub fn ressource_usage(&self) -> RessourceUsage {
-        let disk_size = self.record_log_writer.size();
-        let (memory_size, memory_capacity) = self.in_mem_queues.size();
-        RessourceUsage {
-            memory_size, memory_capacity, disk_size,
+    /// Return the amount of memory and disk space used by mrecordlog.
+    pub fn resource_usage(&self) -> ResourceUsage {
+        let disk_used_bytes = self.record_log_writer.size();
+        let (memory_used_bytes, memory_allocated_bytes) = self.in_mem_queues.size();
+        ResourceUsage {
+            memory_used_bytes,
+            memory_allocated_bytes,
+            disk_used_bytes,
         }
     }
 }

src/tests.rs

@@ -323,25 +323,25 @@ fn test_multi_record_size() {
     let tempdir = tempfile::tempdir().unwrap();
     {
         let mut multi_record_log = MultiRecordLog::open(tempdir.path()).unwrap();
-        assert_eq!(multi_record_log.ressource_usage().memory_size, 0);
-        assert_eq!(multi_record_log.ressource_usage().memory_capacity, 0);
+        assert_eq!(multi_record_log.resource_usage().memory_used_bytes, 0);
+        assert_eq!(multi_record_log.resource_usage().memory_allocated_bytes, 0);
 
         multi_record_log.create_queue("queue").unwrap();
-        let size_mem_create = multi_record_log.ressource_usage();
-        assert!(size_mem_create.memory_size > 0);
-        assert!(size_mem_create.memory_capacity >= size_mem_create.memory_size);
+        let size_mem_create = multi_record_log.resource_usage();
+        assert!(size_mem_create.memory_used_bytes > 0);
+        assert!(size_mem_create.memory_allocated_bytes >= size_mem_create.memory_used_bytes);
 
         multi_record_log
             .append_record("queue", None, &b"hello"[..])
             .unwrap();
-        let size_mem_append = multi_record_log.ressource_usage();
-        assert!(size_mem_append.memory_size > size_mem_create.memory_size);
-        assert!(size_mem_append.memory_capacity >= size_mem_append.memory_size);
-        assert!(size_mem_append.memory_capacity >= size_mem_create.memory_capacity);
+        let size_mem_append = multi_record_log.resource_usage();
+        assert!(size_mem_append.memory_used_bytes > size_mem_create.memory_used_bytes);
+        assert!(size_mem_append.memory_allocated_bytes >= size_mem_append.memory_used_bytes);
+        assert!(size_mem_append.memory_allocated_bytes >= size_mem_create.memory_allocated_bytes);
 
         multi_record_log.truncate("queue", 0).unwrap();
-        let size_mem_truncate = multi_record_log.ressource_usage();
-        assert!(size_mem_truncate.memory_size < size_mem_append.memory_size);
+        let size_mem_truncate = multi_record_log.resource_usage();
+        assert!(size_mem_truncate.memory_used_bytes < size_mem_append.memory_used_bytes);
     }
 }