This is a syntax sugar proc-macro crate for trait, impl accessors patterns. tia generate to an accessor impls of an indivisual traits for any struct|enun|unions.
tia will be generate impl codes automatically if you set the #[tia(...)] directives.struct | enum | uniontrait supporting: Can be generate for multiple traits.
#[tia(MyTrait1: rg, MyTrait2: si)] (See also the Example-3 in below.)gm for get/move pattern; for move-semantics tunings.g for get/implicit copy pattern; for primitive types such as u8.rg for get/reference pattern; for reference usages. (See also the Example-1 in below.)rmg for get/reference mut pattern; for r/w as object.s for set/implicit move/copy pattern; for primitive types such as u8 and Copy-ables.rs for set/explicit copy with Clone::clone_from pattern; for Clone-able without type converting.rsi for set/explicit copy with Into::into pattern; for Into-able input types with type converting if required.print, show a generated codes in building-time via stdcerr.file, output a generated codes to files such as src/.tia/{MyStructSymbol}.rs.file-pretty, file + formatting with rustfmt command.disable, disable all tia features in temporary.get_xxxx | set_xxxx prefixed accessor.rg="awesome", will generate awesome_xxxx prefixed accessor.rg+="awesome", will generate xxxx_awesome suffixed accessor.rg="awesome" will generate awesome fullname defined accessor.tiaIt is minimal, very simple version. Without traits complex.
```rust use tia::Tia; // 1. use
struct MyStruct { foo: i32, bar: String }
fn main() { let mys = MyStruct{ foo: 123, bar: "Hello".into() }; let foo = mys.getfoo(); // <-- 4. !! generated by tia automatically !! let bar = mys.getbar(); // <-- 5. !! generated by tia automatically !! println!("foo={} bar={}", foo, bar ); } ```
cargo run, then you will get the output:
rust
foo=123 bar=Hello
tia.The automatic generated code is:
```rust impl MyStruct { pub fn get_foo(&self) -> &i32 { &self.foo }
pub fn get_bar(&self) -> &String { &self.bar } } ```
It could be output to src/.tia/MyStruct if use file-pretty features in Cargo.toml:
toml
[dependencies]
tia={ version="*", features=["file-pretty"] }
```rust use tia::Tia; // use
struct MyStruct { #[tia(rmg)] // <-- #[tia(rg, s)] + #[tia(rmg)] => #[tia(rmg, s)] foo: i32, #[tia(rsi)] // <-- #[tia(rg, s)] + #[tia(rsi)] => #[tia(rg, rsi)] bar: String,
baz: f64, // <-- #[tia(rg, s)]
#[tia(g)] // <-- #[tia(rg, s)] + #[tia(g)] => #[tia(g, s)] !! NOTE: Could be use for Copy-ables such as u8, but g pattern could not be use non-Copy-ables such as Vec
#[tia(gm)] // <-- #[tia(rg, s)] + #[tia(g)] => #[tia(gm, s)] !! WARNING: Could be move any types, but gm pattern will drop self
hogefuga: Vec
fn main() { let mut mys = MyStruct::default();
// rmg; reference-mut-getter // with per-field level directive overwriting. { let foo = mys.get_foo(); // <-- &mut i32 *foo = 42; dbg!(&foo); dbg!(&mys); }
// rsi: reference-setter-into // with per-field level directive overwriting. { let a: &str = "Hello, "; let b: String = String::from("tia."); let c: &String = &b;
mys.setbar(a); // &str println!("a: mys.bar = {}", mys.getbar());
mys.setbar(b.clone()); // String; This effect move, thus the example is a -> c -> b println!("b: mys.bar = {}", mys.getbar());
mys.setbar(c); // &String println!("c: mys.bar = {}", mys.getbar()); }
let x = mys.get_brabrabra(); // it will be Copy, mys will live dbg!(x, &mys);
let y = mys.get_hogefuga(); // gm, get-move accessor will be drop mys dbg!(y); // mys was dropped, it could not be compile. //dbg!(mys) } ```
cargo run:
rust
[src\main.rs:30] &foo = 42
[src\main.rs:31] &mys = MyStruct {
foo: 42,
bar: "",
baz: 0.0,
brabrabra: 0,
hogefuga: [],
}
a: mys.bar = Hello,
b: mys.bar = tia.
c: mys.bar = tia.
[src\main.rs:52] x = 0
[src\main.rs:52] &mys = MyStruct {
foo: 42,
bar: "tia.",
baz: 0.0,
brabrabra: 0,
hogefuga: [],
}
[src\main.rs:55] y = []
trait usage```rust use tia::Tia;
trait FooGettable
//include!(".tia/MyStruct.rs");
struct MyStruct
{
#[tia(s, "FooGettableg and s: Sushi trait
baz: u8
}
fn main()
{
let mut mys = MyStruct::default();
mys.setfoo(123);
mys.setbar("meow");
let foogettable = &mys as &dyn FooGettable
Then cargo run:
rust
123, meow
32
The generated code with print, file or file-pretty features:
```rust
impl FooGettable
pub fn setfoo(&mut self, v: i32) { self.foo = v; } } impl Fruit for MyStruct { fn getbar(&self) -> &String { &self.bar } } impl Sushi for MyStruct { fn avocado(&mut self, v: u8) { self.baz = v; }
fn tuna(&self) -> u8 { self.baz } } ```
The include feature:
toml
[dependencies]
tia={ version="*", features=["file-pretty","include"] }
tia will be:
include! such as include!("src/.tia/MyStruct") instead.tia provide a useful syntax sugar, it will helpful if you should impl many interface-like specifications. For eg, something designed for object-oriented paradigm mainly languages such as C#, Java, C++, or complex data definition based by UML such as XMLSchema. But, it is just a syntax sugar. Please do not overdose tia unnecessarily.