![github] ![crates-io] ![docs-rs]

tia; trait, impl accessors | automatic

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.

Features

Example

Example-1; The introduction of tia

It is minimal, very simple version. Without traits complex.

```rust use tia::Tia; // 1. use

[derive(Tia)] // 2. derive

[tia(rg)] // 3. tia directives

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:

sh foo=123 bar=Hello

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"] }

Example-2; A little complex/practical usage

```rust use tia::Tia; // use

[derive(Tia, Debug, Default)] // derive

[tia(rg, s)] // <-- tia directives, for all fields

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 brabrabra: u8,

#[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 = []

Example-3; trait usage

```rust use tia::Tia;

trait FooGettable{ fn getfoo(&self) -> T; } trait Fruit{ fn getbar(&self) -> &String; } trait Sushi{ fn tuna(&self) -> u8; fn avocado(&mut self, v: u8); }

//include!(".tia/MyStruct.rs");

[derive(Tia, Debug, Default)] // derive

struct MyStruct { #[tia(s, "FooGettable", g)] foo: i32, #[tia("Fruit",rg,"",rsi)] bar: String, #[tia("Sushi",g="tuna",s="avocado")] // <- g 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; let fruit = &mys as &dyn Fruit; println!("{}, {}", foogettable.getfoo(), fruit.getbar() ); let sushi = &mut mys as &mut dyn Sushi; sushi.avocado(32); println!("{}", sushi.tuna()); } ```

Then cargo run:

sh 123, meow 32

The generated code with print, file or file-pretty features:

```rust impl FooGettable for MyStruct { fn getfoo(&self) -> i32 { self.foo } } impl MyStruct { pub fn setbar>(&mut self, v: T) { self.bar = v.into(); }

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 } } ```

Reference

Usage

  1. Preparing, add tia="*" in [dependencies] section of the project Cargo.toml file. ( Or I like cargo add tia via cargo-edit )
  2. Use:
    1. Write #[derive(Tia)] proc-macro on head of your struct|enum|union.
    2. Write #[tia(...)] proc-macro below the #[derive(Tia)] (for struct|enum|union-level settings) or top of the specific fields.
      • ... is explanate in the next section "tia directives".

tia directives

tia's proc-macro can parse the pattern:

```

[tia( $tiadirective0, $tiadirective1,$tiadirective2, ... )]

```

And the $tia_directive pattern:

  1. Accessor directive
  2. Trait directive

features

disable

Usage example:

toml [dependencies] tia={ version="*", features=["disable"] }

print

Usage example:

toml [dependencies] tia={ version="*", features=["print"] }

file|file-pretty

Usage example:

toml [dependencies] tia={ version="*", features=["file-pretty"] }

What's the difference of file and file-pretty:

include|include-pretty|include-force

Usage example:

toml [dependencies] tia={ version="*", features=["include-pretty"] }

tia will be:

  1. Generate codes if not exists.
  2. Generate include!(...) macro such as include!("src/.tia/MyStruct") instead.

What's the difference of include, include-pretty and include-force:

Note

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.

LICENSE

Contributor

Thank you!😍

Author