Merge pull request #36 from PhaestusFox/main

made set and get take AsRef<str>

Cargo.toml

@@ -33,6 +33,7 @@ directories = "5.0"
 
 [dev-dependencies]
 bevy = { version = "0.10", default-features = false }
+strum_macros = "*"
 
 [build-dependencies]
 cfg_aliases = "0.1"
@@ -55,4 +56,8 @@ required-features = ["bevy"]
 
 [[example]]
 name = "migration"
+required-features = ["bevy"]
+
+[[example]]
+name = "enumkeys"
 required-features = ["bevy"]

examples/enumkeys.rs

@@ -0,0 +1,52 @@
+use bevy::{log::LogPlugin, prelude::*};
+use bevy_pkv::PkvStore;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct User {
+    name: String,
+}
+
+fn setup(mut pkv: ResMut<PkvStore>) {
+    // strings
+    if let Ok(username) = pkv.get::<String>(PkvKeys::UserName) {
+        info!("Welcome back {username}");
+    } else {
+        pkv.set_string(PkvKeys::UserName, "alice")
+            .expect("failed to store username");
+
+        // alternatively, using the slightly less efficient generic api:
+        pkv.set(PkvKeys::UserName, &"alice".to_string())
+            .expect("failed to store username");
+    }
+
+    // serde types
+    if let Ok(user) = pkv.get::<User>(PkvKeys::User) {
+        info!("Welcome back {}", user.name);
+    } else {
+        let user = User {
+            name: "bob".to_string(),
+        };
+        pkv.set(PkvKeys::User, &user)
+            .expect("failed to store User struct");
+    }
+}
+
+fn main() {
+    // When building for WASM, print panics to the browser console
+    #[cfg(target_arch = "wasm32")]
+    console_error_panic_hook::set_once();
+
+    App::new()
+        .insert_resource(PkvStore::new("BevyPkv", "EnumExample"))
+        .add_plugins(MinimalPlugins)
+        .add_plugin(LogPlugin::default())
+        .add_startup_system(setup)
+        .run();
+}
+
+#[derive(strum_macros::AsRefStr)]
+enum PkvKeys {
+    User,
+    UserName,
+}

src/lib.rs

@@ -103,19 +103,19 @@ impl PkvStore {
     }
 
     /// Serialize and store the value
-    pub fn set<T: Serialize>(&mut self, key: &str, value: &T) -> Result<(), SetError> {
-        self.inner.set(key, value)
+    pub fn set<T: Serialize>(&mut self, key: impl AsRef<str>, value: &T) -> Result<(), SetError> {
+        self.inner.set(key.as_ref(), value)
     }
 
     /// More or less the same as set::<String>, but can take a &str
-    pub fn set_string(&mut self, key: &str, value: &str) -> Result<(), SetError> {
-        self.inner.set_string(key, value)
+    pub fn set_string(&mut self, key: impl AsRef<str>, value: &str) -> Result<(), SetError> {
+        self.inner.set_string(key.as_ref(), value)
     }
 
     /// Get the value for the given key
     /// returns Err(GetError::NotFound) if the key does not exist in the key value store.
-    pub fn get<T: DeserializeOwned>(&self, key: &str) -> Result<T, GetError> {
-        self.inner.get(key)
+    pub fn get<T: DeserializeOwned>(&self, key: impl AsRef<str>) -> Result<T, GetError> {
+        self.inner.get(key.as_ref())
     }
 
     /// Clear all key values data