宏实现

Author: tickbh

Cargo.lock

@@ -1,3 +1,6 @@
+[workspace]
+members = ["algorithm-macro"]
+
 [package]
 name = "algorithm"
 version = "0.1.7"
@@ -11,12 +14,15 @@ keywords = ["arc", "lru", "lfu", "timerwheel", "slab"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-lazy_static="1.4.0"
+lazy_static="1.5.0"
 hashbrown="0.14"
 
+[dependencies.algorithm-macro]
+path = "algorithm-macro"
+
 [dev-dependencies]
 rand="0.8.5"
-libc="0.2"
+libc="0.2.158"
 slab = "0.4.9"
 
 [profile.release]
@@ -26,4 +32,4 @@ debug = true
 [features]
 default = ["hashbrown", "ttl"]
 hashbrown=[]
-ttl=[]
+ttl=[]

Cargo.toml

@@ -210,6 +210,27 @@ fn main() {
 ```
 
 
+# 添加宏支持, 可快速的缓存函数的结果
+
+
+```rust
+use algorithm::LruCache;
+use algorithm_macro::cache;
+
+#[cache(LruCache : LruCache::new(20))]
+#[cache_cfg(ignore_args = call_count)]
+#[cache_cfg(thread)]
+fn fib(x: u64, call_count: &mut u32) -> u64 {
+    *call_count += 1;
+    if x <= 1 {
+        1
+    } else {
+        fib(x - 1, call_count) + fib(x - 2, call_count)
+    }
+}
+```
+如此就可以快速将函数的执行结果进行缓存加速.
+
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=tickbh/algorithm-rs&type=Date)](https://star-history.com/#tickbh/algorithm-rs&Date)

README.md

@@ -0,0 +1,18 @@
+[package]
+name = "algorithm-macro"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+quote = "1.0.36"
+lazy_static = "1.2.0"
+proc-macro2 = "1.0.86"
+
+[dependencies.syn]
+version = "2.0.74"
+features = ["full", "extra-traits"]
+
+[lib]
+proc-macro = true

algorithm-macro/Cargo.toml

@@ -0,0 +1,91 @@
+use std::default::Default;
+use std::collections::HashSet;
+
+use quote::ToTokens;
+use syn::{self, Token, parenthesized};
+use syn::parse::{Parse, ParseStream};
+
+pub struct Config {
+    pub ignore_args: HashSet<syn::Ident>,
+    pub use_thread: bool,
+}
+
+struct IgnoreArgsAttrib {
+    ignore_args: HashSet<syn::Ident>,
+}
+
+enum ConfigAttrib {
+    IgnoreArgs(IgnoreArgsAttrib),
+    UseTread,
+}
+
+const CONFIG_ATTRIBUTE_NAME: &'static str = "cache_cfg";
+
+impl Config {
+    // Parse any additional attributes present after `lru_cache` and return a configuration object
+    // created from their contents. Additionally, return any attributes that were not handled here.
+    pub fn parse_from_attributes(attribs: &[syn::Attribute]) -> syn::Result<(Config, Vec<syn::Attribute>)> {
+        let mut parsed_attributes = Vec::new();
+        let mut remaining_attributes = Vec::new();
+
+        for attrib in attribs {
+            let segs = &attrib.path().segments;
+            if segs.len() > 0 {
+                if segs[0].ident == CONFIG_ATTRIBUTE_NAME {
+                    let tokens = attrib.meta.to_token_stream();
+                    let parsed = syn::parse2::<ConfigAttrib>(tokens)?;
+                    parsed_attributes.push(parsed);
+                }
+                else {
+                    remaining_attributes.push(attrib.clone());
+                }
+            }
+        }
+
+        let mut config: Config = Default::default();
+
+        for parsed_attrib in parsed_attributes {
+            match parsed_attrib {
+                ConfigAttrib::IgnoreArgs(val) => config.ignore_args = val.ignore_args,
+                ConfigAttrib::UseTread => config.use_thread = true,
+            }
+        }
+
+        Ok((config, remaining_attributes))
+    }
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            ignore_args: HashSet::new(),
+            use_thread: false,
+        }
+    }
+}
+
+impl Parse for ConfigAttrib {
+    fn parse(input: ParseStream) -> syn::parse::Result<Self> {
+        let _name = input.parse::<syn::Ident>()?;
+        let content;
+        let _paren = parenthesized!(content in input);
+        let name = content.parse::<syn::Ident>()?;
+        match &name.to_string()[..] {
+            "ignore_args" => Ok(ConfigAttrib::IgnoreArgs(content.parse::<IgnoreArgsAttrib>()?)),
+            "thread" => Ok(ConfigAttrib::UseTread),
+            _ => Err(syn::parse::Error::new(
+                name.span(), format!("unrecognized config option '{}'", name.to_string())
+            ))
+        }
+    }
+}
+
+impl Parse for IgnoreArgsAttrib {
+    fn parse(input: ParseStream) -> syn::parse::Result<Self> {
+        input.parse::<Token![=]>()?;
+        let elems = syn::punctuated::Punctuated::<syn::Ident, Token![,]>::parse_terminated(input)?;
+        Ok(IgnoreArgsAttrib {
+            ignore_args: elems.into_iter().collect(),
+        })
+    }
+}