From b5878a870442d46a0cb863809c00aa7da9d7bdff Mon Sep 17 00:00:00 2001
From: Liam Kinne <liam@kinne.io>
Date: Mon, 22 Jul 2024 02:26:22 +1000
Subject: [PATCH 1/3] add defmt attributes for caches

---
 src/cache/key_pointers.rs  | 2 ++
 src/cache/mod.rs           | 5 +++++
 src/cache/page_pointers.rs | 2 ++
 src/cache/page_states.rs   | 2 ++
 4 files changed, 11 insertions(+)

diff --git a/src/cache/key_pointers.rs b/src/cache/key_pointers.rs
index 8719772..d16c5c7 100644
--- a/src/cache/key_pointers.rs
+++ b/src/cache/key_pointers.rs
@@ -12,6 +12,7 @@ pub(crate) trait KeyPointersCache<KEY: Key> {
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct CachedKeyPointers<KEY: Eq, const KEYS: usize> {
     key_pointers: [Option<(KEY, NonZeroU32)>; KEYS],
 }
@@ -77,6 +78,7 @@ impl<KEY: Key, const KEYS: usize> KeyPointersCache<KEY> for CachedKeyPointers<KE
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct UncachedKeyPointers;
 
 impl<KEY: Key> KeyPointersCache<KEY> for UncachedKeyPointers {
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 7c9ef27..339a0ac 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -164,6 +164,7 @@ impl<KEY: Key, T: PrivateKeyCacheImpl<KEY>> PrivateKeyCacheImpl<KEY> for &mut T
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct DirtTracker {
     /// Managed from the library code.
     ///
@@ -198,6 +199,7 @@ impl DirtTracker {
 /// This type of cache doesn't have to be kept around and may be constructed on every api call.
 /// You could simply pass `&mut NoCache::new()` every time.
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub struct NoCache {
     page_states: UncachedPageStates,
     page_pointers: UncachedPagePointers,
@@ -266,6 +268,7 @@ impl<KEY: Key> PrivateKeyCacheImpl<KEY> for NoCache {
 ///
 /// Make sure the page count is correct. If the number is lower than the actual amount, the code will panic at some point.
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub struct PageStateCache<const PAGE_COUNT: usize> {
     dirt_tracker: DirtTracker,
     page_states: CachedPageStates<PAGE_COUNT>,
@@ -339,6 +342,7 @@ impl<KEY: Key, const PAGE_COUNT: usize> PrivateKeyCacheImpl<KEY> for PageStateCa
 ///
 /// Make sure the page count is correct. If the number is lower than the actual amount, the code will panic at some point.
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub struct PagePointerCache<const PAGE_COUNT: usize> {
     dirt_tracker: DirtTracker,
     page_states: CachedPageStates<PAGE_COUNT>,
@@ -417,6 +421,7 @@ impl<KEY: Key, const PAGE_COUNT: usize> PrivateKeyCacheImpl<KEY> for PagePointer
 /// the chance of a cache hit.
 /// The keys are cached in a fifo and any time its location is updated in cache it's added to the front.
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub struct KeyPointerCache<const PAGE_COUNT: usize, KEY: Key, const KEYS: usize> {
     dirt_tracker: DirtTracker,
     page_states: CachedPageStates<PAGE_COUNT>,
diff --git a/src/cache/page_pointers.rs b/src/cache/page_pointers.rs
index ee1b6dc..34f4280 100644
--- a/src/cache/page_pointers.rs
+++ b/src/cache/page_pointers.rs
@@ -29,6 +29,7 @@ pub(crate) trait PagePointersCache: Debug {
 
 // Use NoneZeroU32 because we never store 0's in here (because of the first page marker)
 // and so Option can make use of the niche so we save bytes
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct CachedPagePointers<const PAGE_COUNT: usize> {
     after_erased_pointers: [Option<NonZeroU32>; PAGE_COUNT],
     after_written_pointers: [Option<NonZeroU32>; PAGE_COUNT],
@@ -138,6 +139,7 @@ impl<const PAGE_COUNT: usize> PagePointersCache for CachedPagePointers<PAGE_COUN
 }
 
 #[derive(Debug, Default)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct UncachedPagePointers;
 
 impl PagePointersCache for UncachedPagePointers {
diff --git a/src/cache/page_states.rs b/src/cache/page_states.rs
index eaddddc..6df9b8c 100644
--- a/src/cache/page_states.rs
+++ b/src/cache/page_states.rs
@@ -8,6 +8,7 @@ pub(crate) trait PageStatesCache: Debug {
     fn invalidate_cache_state(&mut self);
 }
 
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct CachedPageStates<const PAGE_COUNT: usize> {
     pages: [Option<PageState>; PAGE_COUNT],
 }
@@ -55,6 +56,7 @@ impl<const PAGE_COUNT: usize> PageStatesCache for CachedPageStates<PAGE_COUNT> {
 }
 
 #[derive(Debug, Default)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub(crate) struct UncachedPageStates;
 
 impl PageStatesCache for UncachedPageStates {

From 504f1f2faafce5213b3c9f4cfb934c83f950bc38 Mon Sep 17 00:00:00 2001
From: Liam Kinne <liam@kinne.io>
Date: Mon, 22 Jul 2024 10:02:16 +1000
Subject: [PATCH 2/3] add changelog entry

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 15f5d0b..8705d23 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 ## Unreleased
 
+- Add `defmt` attributes to cache types.
+
 ## 3.0.0 17-07-24
 
 - *Breaking:* Map keys are now always passed by reference. This avoids extra cloning and memory use for bigger keys.

From 202bb6bbab041d856efb2765b9a9fa179be2d1a9 Mon Sep 17 00:00:00 2001
From: Liam Kinne <liam@kinne.io>
Date: Fri, 26 Jul 2024 00:44:30 +1000
Subject: [PATCH 3/3] fix missing attribute

---
 src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/lib.rs b/src/lib.rs
index 3b9d8bc..567c4ab 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -329,6 +329,7 @@ async fn partial_close_page<S: NorFlash>(
 
 /// The state of a page
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 enum PageState {
     /// This page was fully written and has now been sealed
     Closed,