rename OrderlyAllocator -> Allocator

The consumer can `use _ as _` if they like.

reword docs

Author: ickk

README.md

@@ -1,13 +1,13 @@
 `orderly-allocator`
 ===================
 
-A super simple fast soft-realtime allocator for managing an external pool of
-memory
+A super-simple fast soft-realtime allocator for managing an external pool of
+memory.
 
 Since the pool of memory it manages is external, it could be useful as a
 suballocator for e.g. a GPU buffer.
 
-Has worst-case *O(log(n))* performance for `alloc` & `free`, but provides a
+Has worst-case *O(log(n))*\* performance for `alloc` & `free`, but provides a
 *best-fit* search strategy & immediately coalesces on `free` resulting in low
 fragmentation.
 
@@ -26,11 +26,11 @@ implementation.
 
 ### Future Work
 
-Currently, the BTree implementation at the heart of `orderly-allocator` asks
+*Currently, the BTree implementation at the heart of `orderly-allocator` asks
 the global-allocator for memory for newly-created nodes every now and then. It
 would be possible to turn this into a firm- or hard-realtime allocator by using
-a different BTree implementation which pulled new nodes from a preallocated
-set.
+a different BTree implementation which preallocated as set of nodes ahead of
+time.
 
 
 ### Other Libraries
@@ -54,6 +54,7 @@ This crate is licensed under any of the [Apache license 2.0], or the
 [MIT license]: ./LICENSE-MIT
 [Zlib license]: ./LICENSE-ZLIB
 
+
 ### Contribution
 
 Unless explicitly stated otherwise, any contributions you intentionally submit

src/lib.rs

@@ -18,7 +18,7 @@ pub struct Allocation {
   pub size: NonZero<Size>,
 }
 
-/// A super simple fast soft-realtime allocator for managing an external pool
+/// A super-simple fast soft-realtime allocator for managing an external pool
 /// of memory
 ///
 /// Since the pool of memory it manages is external, it could be useful as a
@@ -35,7 +35,7 @@ pub struct Allocation {
 /// ~100,000 separate free-regions, a worst-case lookup will traverse only 5
 /// tree nodes.
 #[derive(Clone)]
-pub struct OrderlyAllocator {
+pub struct Allocator {
   /// An ordered collection of free-regions, sorted primarily by size, then by
   /// location
   free: BTreeSet<FreeRegion>,
@@ -74,15 +74,15 @@ impl Ord for FreeRegion {
   }
 }
 
-impl OrderlyAllocator {
+impl Allocator {
   /// Create a new allocator to manage a pool of memory
   ///
   /// Panics:
   /// - Panics if `capacity == 0`
   pub fn new(capacity: Size) -> Self {
     let capacity = NonZero::new(capacity).expect("`capacity == 0`");
 
-    let mut allocator = OrderlyAllocator {
+    let mut allocator = Allocator {
       free: BTreeSet::new(),
       location_map: BTreeMap::new(),
       capacity,
@@ -290,9 +290,9 @@ impl OrderlyAllocator {
   }
 }
 
-impl fmt::Debug for OrderlyAllocator {
+impl fmt::Debug for Allocator {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    f.debug_struct("OrderlyAllocator")
+    f.debug_struct("Allocator")
       .field(&"capacity", &self.capacity)
       .field(&"total_available", &self.available)
       .field(&"largest_available", &self.largest_available())