Update in-code docs to mention CloneGetters

Author: jbaublitz

src/lib.rs

@@ -8,46 +8,61 @@ Getters are generated as `fn field(&self) -> &type`, while setters are generated
 These macros are not intended to be used on fields which require custom logic inside of their setters and getters. Just write your own in that case!
 
 ```rust
-use getset::{CopyGetters, Getters, MutGetters, Setters};
+use std::sync::Arc;
 
-#[derive(Getters, Setters, MutGetters, CopyGetters, Default)]
+use getset::{CloneGetters, CopyGetters, Getters, MutGetters, Setters, WithSetters};
+
+#[derive(Getters, Setters, WithSetters, MutGetters, CopyGetters, CloneGetters, Default)]
 pub struct Foo<T>
 where
     T: Copy + Clone + Default,
 {
     /// Doc comments are supported!
     /// Multiline, even.
-    #[getset(get, set, get_mut)]
+    #[getset(get, set, get_mut, set_with)]
     private: T,
 
     /// Doc comments are supported!
     /// Multiline, even.
-    #[getset(get_copy = "pub", set = "pub", get_mut = "pub")]
+    #[getset(get_copy = "pub", set = "pub", get_mut = "pub", set_with = "pub")]
     public: T,
+
+    /// Arc supported through CloneGetters
+    #[getset(get_clone = "pub", set = "pub", get_mut = "pub", set_with = "pub")]
+    arc: Arc<u16>,
 }
 
-let mut foo = Foo::default();
-foo.set_private(1);
-(*foo.private_mut()) += 1;
-assert_eq!(*foo.private(), 2);
+fn main() {
+    let mut foo = Foo::default();
+    foo.set_private(1);
+    (*foo.private_mut()) += 1;
+    assert_eq!(*foo.private(), 2);
+    foo = foo.with_private(3);
+    assert_eq!(*foo.private(), 3);
+    assert_eq!(*foo.arc(), 0);
+}
 ```
 
 You can use `cargo-expand` to generate the output. Here are the functions that the above generates (Replicate with `cargo expand --example simple`):
 
 ```rust,ignore
-use getset::{Getters, MutGetters, CopyGetters, Setters, WithSetters};
+use std::sync::Arc;
+use getset::{CloneGetters, CopyGetters, Getters, MutGetters, Setters, WithSetters};
 pub struct Foo<T>
 where
     T: Copy + Clone + Default,
 {
     /// Doc comments are supported!
     /// Multiline, even.
-    #[getset(get, get, get_mut)]
+    #[getset(get, set, get_mut, set_with)]
     private: T,
     /// Doc comments are supported!
     /// Multiline, even.
-    #[getset(get_copy = "pub", set = "pub", get_mut = "pub")]
+    #[getset(get_copy = "pub", set = "pub", get_mut = "pub", set_with = "pub")]
     public: T,
+    /// Arc supported through CloneGetters
+    #[getset(get_clone = "pub", set = "pub", get_mut = "pub", set_with = "pub")]
+    arc: Arc<u16>,
 }
 impl<T> Foo<T>
 where
@@ -64,13 +79,51 @@ impl<T> Foo<T>
 where
     T: Copy + Clone + Default,
 {
+    /// Doc comments are supported!
+    /// Multiline, even.
+    #[inline(always)]
+    fn set_private(&mut self, val: T) -> &mut Self {
+        self.private = val;
+        self
+    }
     /// Doc comments are supported!
     /// Multiline, even.
     #[inline(always)]
     pub fn set_public(&mut self, val: T) -> &mut Self {
         self.public = val;
         self
     }
+    /// Arc supported through CloneGetters
+    #[inline(always)]
+    pub fn set_arc(&mut self, val: Arc<u16>) -> &mut Self {
+        self.arc = val;
+        self
+    }
+}
+impl<T> Foo<T>
+where
+    T: Copy + Clone + Default,
+{
+    /// Doc comments are supported!
+    /// Multiline, even.
+    #[inline(always)]
+    fn with_private(mut self, val: T) -> Self {
+        self.private = val;
+        self
+    }
+    /// Doc comments are supported!
+    /// Multiline, even.
+    #[inline(always)]
+    pub fn with_public(mut self, val: T) -> Self {
+        self.public = val;
+        self
+    }
+    /// Arc supported through CloneGetters
+    #[inline(always)]
+    pub fn with_arc(mut self, val: Arc<u16>) -> Self {
+        self.arc = val;
+        self
+    }
 }
 impl<T> Foo<T>
 where
@@ -88,6 +141,11 @@ where
     pub fn public_mut(&mut self) -> &mut T {
         &mut self.public
     }
+    /// Arc supported through CloneGetters
+    #[inline(always)]
+    pub fn arc_mut(&mut self) -> &mut Arc<u16> {
+        &mut self.arc
+    }
 }
 impl<T> Foo<T>
 where
@@ -100,6 +158,16 @@ where
         self.public
     }
 }
+impl<T> Foo<T>
+where
+    T: Copy + Clone + Default,
+{
+    /// Arc supported through CloneGetters
+    #[inline(always)]
+    pub fn arc(&self) -> Arc<u16> {
+        self.arc.clone()
+    }
+}
 ```
 
 Attributes can be set on struct level for all fields in struct as well. Field level attributes take