Ready 0.5 release.

Signed-off-by: Tin Švagelj <[email protected]>

Cargo.toml

@@ -15,10 +15,10 @@ path = "examples/ptr_metadata.rs"
 required-features = ["ptr_metadata"]
 
 [features]
-default = ["unsafe_impl", "ptr_metadata", "debug"]
+default = ["unsafe_impl", "debug"]
 
 no_std = [] # No-std support
-debug = [] # Enable debug attributes
+debug = []  # Enable debug attributes
 
 # Implementations
 unsafe_impl = []

README.md

@@ -1,7 +1,7 @@
 # contiguous_mem
 
 contiguous_mem is a vector like collection that can store entries with
-heterogeneous layouts while retaining type safety at the reference level.
+heterogeneous layouts while retaining type information at the reference level.
 
 [![Crate](https://img.shields.io/crates/v/contiguous_mem?style=for-the-badge&logo=docs.rs)](https://crates.io/crates/contiguous_mem)
 [![Documentation](https://img.shields.io/docsrs/contiguous-mem?style=for-the-badge&logo=rust)](https://docs.rs/contiguous-mem)
@@ -32,7 +32,8 @@ over when your scope and requirements shift.
 ## Use cases
 
 - Storing differently typed/sized data. ([example](./examples/default_impl.rs))
-- Ensuring stored data is placed adjacently in memory. ([example](./examples/game_loading.rs))
+- Ensuring stored data is placed adjacently in memory.
+  ([example](./examples/game_loading.rs))
   - Note that returned references are **not** contiguous, only data they refer
     to is.
 
@@ -42,14 +43,14 @@ Add the crate to your dependencies:
 
 ```toml
 [dependencies]
-contiguous_mem = { version = "0.4" }
+contiguous_mem = { version = "0.5" }
 ```
 
 Optionally enable `no_std` feature to use in `no_std` environment:
 
 ```toml
 [dependencies]
-contiguous_mem = { version = "0.4", features = ["no_std"] }
+contiguous_mem = { version = "0.5", features = ["no_std"] }
 ```
 
 ### Features

doc/crate.md

@@ -1,5 +1,5 @@
 contiguous_mem is a vector like collection that can store entries with
-heterogeneous layouts while retaining type safety at the reference level.
+heterogeneous layouts while retaining type information at the reference level.
 
 ## Features
 

examples/default_impl.rs

@@ -17,4 +17,8 @@ fn main() {
     // Retrieve and use the stored data
     assert_eq!(*stored_data.get(), data);
     assert_eq!(*stored_number.get(), 22);
+
+    // All stored data gets cleaned up once `memory` goes out of scope, or we
+    // can forget it existed:
+    memory.forget();
 }

examples/unsafe_impl.rs

@@ -6,7 +6,8 @@ struct Data {
 }
 
 fn main() {
-    // Create a ContiguousMemory instance with a capacity of 1024 bytes and 1-byte alignment
+    // Create a ContiguousMemory instance with a capacity of 1024 bytes and
+    // 1-byte alignment
     let mut memory = ContiguousMemory::<ImplUnsafe>::with_capacity(1024);
 
     // Store data in the memory container
@@ -22,4 +23,8 @@ fn main() {
         assert!(!stored_number.is_null());
         assert_eq!(*stored_number, 22);
     }
+
+    // All stored data gets cleaned up once `memory` goes out of scope, or we
+    // can forget it existed:
+    memory.forget();
 }

src/error.rs

@@ -3,31 +3,34 @@
 #[cfg(any(feature = "error_in_core", not(feature = "no_std")))]
 use crate::types::Error;
 
+use core::fmt::Debug;
 #[cfg(any(not(feature = "no_std"), feature = "error_in_core"))]
 use core::fmt::{Display, Formatter, Result as FmtResult};
-use core::{cell::Ref, fmt::Debug};
 
-use crate::{
-    memory::ManageMemory,
-    range::ByteRange,
-    reference::BorrowState,
-    types::{ImplDetails, ImplReferencing, ReadableInner, WritableInner},
-};
+use crate::{range::ByteRange, reference::BorrowState};
 
 /// Represents a class of errors returned by invalid memory operations and
-/// allocator failiure.
+/// allocator failure.
 #[derive(Debug, Clone, Copy)]
 pub enum MemoryError {
     /// Tried allocating container capacity larger than `isize::MAX`
     TooLarge,
     /// Allocation failure caused by either resource exhaustion or invalid
     /// arguments being provided to an allocator.
     Allocator(
-        #[cfg(feature = "allocator_api")] core::alloc::AllocError,
+        /// Cause allocator error.
+        #[cfg(feature = "allocator_api")]
+        core::alloc::AllocError,
         #[cfg(not(feature = "allocator_api"))] (),
     ),
 }
 
+impl From<core::alloc::LayoutError> for MemoryError {
+    fn from(_: core::alloc::LayoutError) -> Self {
+        Self::TooLarge
+    }
+}
+
 #[cfg(any(not(feature = "no_std"), feature = "error_in_core"))]
 impl Display for MemoryError {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
@@ -59,8 +62,8 @@ impl From<core::alloc::AllocError> for MemoryError {
     }
 }
 
-/// Error returned when concurrent mutable access is attempted to the same
-/// memory region.
+/// Error returned when concurrent mutable access to the same memory region is
+/// attempted.
 #[derive(Debug)]
 pub struct RegionBorrowError {
     /// Range that was attempted to be borrowed.