Crate o2o

source ·
Expand description

§Object to Object mapper for Rust. Derive (Try)From, and (Try)Into traits.

github.com crates.io docs.rs

§Quick pitch

impl From<Person> for PersonDto {
    fn from(value: Person) -> PersonDto {
        PersonDto {
            id: value.id,
            name: value.name,
            age: value.age,
        }
    }
}

Writing code like above is not the most exciting or emotionally rewarding part of working with Rust. If you’re Ok with letting procedural macro write it for you, welcome to the rest of this page.

§Basic Example

use o2o::o2o;

struct Person {
    id: u32,
    name: String,
    age: u8
}

#[derive(o2o)]
#[from_owned(Person)] // This tells o2o to generate 'From<Person> for PersonDto' implementation
#[owned_try_into(Person, std::io::Error)] // This generates 'TryInto<Person> for PersonDto' with type Error = std::io::Error
struct PersonDto {
    id: u32,
    name: String,
    age: u8
}

// Applying #[derive(o2o)] on PersonDto allows you to do this:

let person = Person { id: 123, name: "John".into(), age: 42 };
let dto = PersonDto::from(person);

assert_eq!(dto.id, 123); assert_eq!(dto.name, "John"); assert_eq!(dto.age, 42);

// and this:

let dto = PersonDto { id: 321, name: "Jack".into(), age: 23 };
let person: Person = dto.try_into().unwrap();

assert_eq!(person.id, 321); assert_eq!(person.name, "Jack"); assert_eq!(person.age, 23);

// o2o also supports enums:

enum Creature {
    Person(Person),
    Cat { nickname: String },
    Dog(String),
    Other
}

#[derive(o2o)]
#[from_owned(Creature)]
enum CreatureDto {
    Person(#[from(~.into())] PersonDto),
    Cat { nickname: String },
    Dog(String),
    Other
}

let creature = Creature::Cat { nickname: "Floppa".into() };
let dto: CreatureDto = creature.into();

if let CreatureDto::Cat { nickname } = dto { assert_eq!(nickname, "Floppa"); } else { assert!(false) }

And here’s the code that o2o generates (from here on, generated code is produced by rust-analyzer: Expand macro recursively command):

View generated code
impl ::core::convert::From<Person> for PersonDto {
    fn from(value: Person) -> PersonDto {
        PersonDto {
            id: value.id,
            name: value.name,
            age: value.age,
        }
    }
}
impl ::core::convert::TryInto<Person> for PersonDto {
    type Error = std::io::Error;
    fn try_into(self) -> Result<Person, std::io::Error> {
        Ok(Person {
            id: self.id,
            name: self.name,
            age: self.age,
        })
    }
}

impl ::core::convert::From<Creature> for CreatureDto {
    fn from(value: Creature) -> CreatureDto {
        match value {
            Creature::Person(f0) => CreatureDto::Person(f0.into()),
            Creature::Cat { nickname } => CreatureDto::Cat { nickname: nickname },
            Creature::Dog(f0) => CreatureDto::Dog(f0),
            Creature::Other => CreatureDto::Other,
        }
    }
}

§Some milestones

  • v0.4.9 Support for #![no_std]
  • v0.4.4 Fallible conversions
  • v0.4.3 Enum-to-primitive type conversions with #[literal(...)] and #[pattern(...)]
  • v0.4.2 Basic enum conversions

§Content

§Traits and o2o trait instructions

To let o2o know what traits you want implemented, you have to use type-level o2o trait instructions (i.e. proc macro attributes):

struct Entity { }

#[derive(o2o::o2o)]
#[from_ref(Entity)] // This tells o2o to generate 'From<&Entity> for EntityDto' implementation
struct EntityDto { }

o2o procedural macro is able to generate implementation of 12 kinds of traits:

// When applied to a struct B:

// #[from_owned(A)]
impl ::core::convert::From<A> for B { ... }

// #[try_from_owned(A)]
impl ::core::convert::TryFrom<A> for B { ... }

// #[from_ref(A)]
impl ::core::convert::From<&A> for B { ... }

// #[try_from_ref(A)]
impl ::core::convert::TryFrom<&A> for B { ... }

// #[owned_into(A)]
impl ::core::convert::Into<A> for B { ... }

// #[try_owned_into(A)]
impl ::core::convert::TryInto<A> for B { ... }

// #[ref_into(A)]
impl ::core::convert::Into<A> for &B { ... }

// #[try_ref_into(A)]
impl ::core::convert::TryInto<A> for &B { ... }

// #[owned_into_existing(A)]
impl o2o::traits::IntoExisting<A> for B { ... }

// #[owned_try_into_existing(A)]
impl o2o::traits::TryIntoExisting<A> for B { ... }

// #[ref_into_existing(A)]
impl o2o::traits::IntoExisting<A> for &B { ... }

// #[ref_try_into_existing(A)]
impl o2o::traits::TryIntoExisting<A> for &B { ... }

o2o also has shortcuts to configure multiple trait implementations with fewer lines of code:

#[map()]#[from()]#[into()]#[map_owned()]#[map_ref()]#[into_existing()]
#[from_owned()]✔️✔️✔️
#[from_ref()]✔️✔️✔️
#[owned_into()]✔️✔️✔️
#[ref_into()]✔️✔️✔️
#[owned_into_existing()]✔️
#[ref_into_existing()]✔️

E.g. following two bits of code are equivalent:

struct Entity { }

#[derive(o2o::o2o)]
#[map(Entity)]
struct EntityDto { }
struct Entity { }

#[derive(o2o::o2o)]
#[from_owned(Entity)]
#[from_ref(Entity)]
#[owned_into(Entity)]
#[ref_into(Entity)]
struct EntityDto { }

Exactly the same shortcuts apply to fallible conversions.

§Installation

In a typical project just add this to Cargo.toml:

[dependencies]
o2o = "0.4.9"

§no_std

In #![no_std] project, add this to Cargo.toml:

[dependencies]
o2o-macros = "0.4.9"
# Following line can be ommited if you don't need o2o to produce o2o::traits::(Try)IntoExisting implementations
o2o = { version = "0.4.9", default-features = false }

§The (not so big) Problem

This section may be useful for people which are not very familiar with Rust’s procedural macros and it explains why some things are done the way they’re done.

Being procedural macro, o2o has knowledge only about the side of the mapping where #[derive(o2o)] is applied.

#[derive(o2o::o2o)]
#[map(Entity)]
struct EntityDto { }

In code above, o2o knows everything about EntityDto, but it knows nothing about Entity. It doens’t know if it is a struct, doesn’t know what fields it has, doesn’t know if it is a struct or a tuple, it doesn’t even know if it exists.

So unlike mappers from languages like C#, Java, Go etc. that can use reflection to find out what they need to know, o2o can only assume things.

For the piece of code above, o2o will assume that:

  • Entity exists (duh!)
  • Entity is the same data type that EntityDto is (in this case a struct)
  • Entity has exactly the same fields that EntityDto has

If o2o is wrong in any of its assumptions, you will have to tell it that.

§Inline expressions

o2o has a concept of Inline Expressions, which can be passed as a parameter to some of the o2o instructions. You can think of inline expression as a closure, which always has two implicit params: |@, ~| { …expression body… } or |@, ~| { …expression body… }

  • @ represents the object that is being converted from.
  • ~ represents the path to a specific field of the object that is being converted from.
struct Entity { some_int: i32 }

#[derive(o2o::o2o)]
#[map_owned(Entity)] // tells o2o to implement 'From<Entity> for EntityDto' and 'Into<Entity> for EntityDto'
struct EntityDto { 
    #[from(~ * 2)] // Let's say for whatever reason we want to multiply 'some_int' by 2 when converting from Entity
    #[into(~ / 2)] // And divide back by 2 when converting into it
    some_int: i32
}

This example will be expanded into the following code:

impl ::core::convert::From<Entity> for EntityDto {
    fn from(value: Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int * 2, // '~' got replaced by 'value.some_int' for From<> implementation
        }
    }
}
impl ::core::convert::Into<Entity> for EntityDto {
    fn into(self) -> Entity {
        Entity {
            some_int: self.some_int / 2, // '~' got replaced by 'self.some_int' for Into<> implementation
        }
    }
}

To achieve the same result, @ could have been used:

struct Entity { some_int: i32 }

#[derive(o2o::o2o)]
#[map_owned(Entity)]
struct EntityDto { 
    #[from(@.some_int * 2)]
    #[into(@.some_int / 2)]
    some_int: i32
}

This expands into exactly the same code:

impl ::core::convert::From<Entity> for EntityDto {
    fn from(value: Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int * 2, // '@' got replaced by 'value' for From<> implementation
        }
    }
}
impl ::core::convert::Into<Entity> for EntityDto {
    fn into(self) -> Entity {
        Entity {
            some_int: self.some_int / 2, // '@' got replaced by 'self' for Into<> implementation
        }
    }
}

You can use ~ for inline expressions that are passed only to member level o2o instructions, while @ can be used at both member and type level.

So finally, let’s look at some examples.

§Struct Examples

§Different member name

use o2o::o2o;

struct Entity {
    some_int: i32,
    another_int: i16,
}

enum EntityEnum {
    Entity(Entity),
    SomethingElse { field: i32 }
}

#[derive(o2o)]
#[map_ref(Entity)]
struct EntityDto {
    some_int: i32,
    #[map(another_int)]
    different_int: i16,
}

#[derive(o2o)]
#[map_ref(EntityEnum)]
enum EntityEnumDto {
    #[map(Entity)]
    EntityDto(#[map(~.into())]EntityDto),
    SomethingElse { 
        #[map(field, *~)]
        f: i32 
    }
}
View generated code
impl ::core::convert::From<&Entity> for EntityDto {
    fn from(value: &Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            different_int: value.another_int,
        }
    }
}
impl o2o::traits::IntoExisting<Entity> for &EntityDto {
    fn into_existing(self, other: &mut Entity) {
        other.some_int = self.some_int;
        other.another_int = self.different_int;
    }
}

impl ::core::convert::From<&EntityEnum> for EntityEnumDto {
    fn from(value: &EntityEnum) -> EntityEnumDto {
        match value {
            EntityEnum::Entity(f0) => EntityEnumDto::EntityDto(f0.into()),
            EntityEnum::SomethingElse { field } => EntityEnumDto::SomethingElse { f: *field },
        }
    }
}
impl ::core::convert::Into<EntityEnum> for &EntityEnumDto {
    fn into(self) -> EntityEnum {
        match self {
            EntityEnumDto::EntityDto(f0) => EntityEnum::Entity(f0.into()),
            EntityEnumDto::SomethingElse { f } => EntityEnum::SomethingElse { field: *f },
        }
    }
}

§Different field type

use o2o::o2o;

struct Entity {
    some_int: i32,
    str: String,
    val: i16
}

#[derive(o2o)]
#[from(Entity)]
#[try_into(Entity, std::num::ParseIntError)]
struct EntityDto {
    some_int: i32,
    #[map_ref(@.str.clone())] 
    str: String,
    #[from(~.to_string())]
    #[into(~.parse::<i16>()?)]
    val: String
}
View generated code
impl ::core::convert::From<Entity> for EntityDto {
    fn from(value: Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            str: value.str,
            val: value.val.to_string(),
        }
    }
}
impl ::core::convert::From<&Entity> for EntityDto {
    fn from(value: &Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            str: value.str.clone(),
            val: value.val.to_string(),
        }
    }
}
impl ::core::convert::TryInto<Entity> for EntityDto {
    type Error = std::num::ParseIntError;
    fn try_into(self) -> Result<Entity, std::num::ParseIntError> {
        Ok(Entity {
            some_int: self.some_int,
            str: self.str,
            val: self.val.parse::<i16>()?,
        })
    }
}
impl ::core::convert::TryInto<Entity> for &EntityDto {
    type Error = std::num::ParseIntError;
    fn try_into(self) -> Result<Entity, std::num::ParseIntError> {
        Ok(Entity {
            some_int: self.some_int,
            str: self.str.clone(),
            val: self.val.parse::<i16>()?,
        })
    }
}

§Nested structs

use o2o::o2o;

struct Entity {
    some_int: i32,
    child: Child,
}
struct Child {
    child_int: i32,
}

#[derive(o2o)]
#[from_owned(Entity)]
struct EntityDto {
    some_int: i32,
    #[map(~.into())]
    child: ChildDto
}

#[derive(o2o)]
#[from_owned(Child)]
struct ChildDto {
    child_int: i32,
}
View generated code
impl ::core::convert::From<Entity> for EntityDto {
    fn from(value: Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            child: value.child.into(),
        }
    }
}

impl ::core::convert::From<Child> for ChildDto {
    fn from(value: Child) -> ChildDto {
        ChildDto {
            child_int: value.child_int,
        }
    }
}

§Nested collection

use o2o::o2o;

struct Entity {
    some_int: i32,
    children: Vec<Child>,
}
struct Child {
    child_int: i32,
}

#[derive(o2o)]
#[map_owned(Entity)]
struct EntityDto {
    some_int: i32,
    #[map(children, ~.iter().map(|p|p.into()).collect())]
    children_vec: Vec<ChildDto>
}

#[derive(o2o)]
#[map_ref(Child)]
struct ChildDto {
    child_int: i32,
}
View generated code
impl ::core::convert::From<Entity> for EntityDto {
    fn from(value: Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            children_vec: value.children.iter().map(|p| p.into()).collect(),
        }
    }
}
impl ::core::convert::Into<Entity> for EntityDto {
    fn into(self) -> Entity {
        Entity {
            some_int: self.some_int,
            children: self.children_vec.iter().map(|p| p.into()).collect(),
        }
    }
}
impl ::core::convert::From<&Child> for ChildDto {
    fn from(value: &Child) -> ChildDto {
        ChildDto {
            child_int: value.child_int,
        }
    }
}
impl ::core::convert::Into<Child> for &ChildDto {
    fn into(self) -> Child {
        Child {
            child_int: self.child_int,
        }
    }
}

§Assymetric fields (skipping and providing default values)

o2o is able to handle scenarios when either of the structs has a field that the other struct doesn’t have.

For the scenario where you put o2o instructions on a struct that contains extra field:

use o2o::o2o;

struct Person {
    id: i32,
    full_name: String,
    age: i8,
}

#[derive(o2o)]
#[map_owned(Person)]
struct PersonDto {
    id: i32,
    full_name: String,
    age: i8,
    // {None} below provides default value when creating PersonDto from Person
    // It could have been omited if we only needed to create Person from PersonDto
    #[ghost({None})]
    zodiac_sign: Option<ZodiacSign>
}
enum ZodiacSign {}
View generated code
impl ::core::convert::From<Person> for PersonDto {
    fn from(value: Person) -> PersonDto {
        PersonDto {
            id: value.id,
            full_name: value.full_name,
            age: value.age,
            zodiac_sign: None,
        }
    }
}
impl ::core::convert::Into<Person> for PersonDto {
    fn into(self) -> Person {
        Person {
            id: self.id,
            full_name: self.full_name,
            age: self.age,
        }
    }
}

In a reverse case, you need to use a struct level #[ghosts()] instruction:

use o2o::o2o;

#[derive(o2o)]
#[map_owned(PersonDto)]
#[ghosts(zodiac_sign: {None})]
struct Person {
    id: i32,
    full_name: String,
    age: i8,
}

struct PersonDto {
    id: i32,
    full_name: String,
    age: i8,
    zodiac_sign: Option<ZodiacSign>
}
enum ZodiacSign {}
View generated code
impl ::core::convert::From<PersonDto> for Person {
    fn from(value: PersonDto) -> Person {
        Person {
            id: value.id,
            full_name: value.full_name,
            age: value.age,
        }
    }
}
impl ::core::convert::Into<PersonDto> for Person {
    fn into(self) -> PersonDto {
        PersonDto {
            id: self.id,
            full_name: self.full_name,
            age: self.age,
            zodiac_sign: None,
        }
    }
}

§Use struct update syntax (..Default::default())

use o2o::o2o;

#[derive(Default)]
struct Entity {
    some_int: i32,
    some_float: f32
}

#[derive(Default, o2o)]
#[from(Entity| ..get_default())]
#[into(Entity| ..Default::default())]
struct EntityDto {
    some_int: i32,
    #[ghost]
    some_string: String
}

fn get_default() -> EntityDto {
    EntityDto { some_int: 0, some_string: "test".into() }
}
View generated code
impl ::core::convert::From<&Entity> for EntityDto {
    fn from(value: &Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            ..get_default()
        }
    }
}
impl ::core::convert::Into<Entity> for EntityDto {
    fn into(self) -> Entity {
        Entity {
            some_int: self.some_int,
            ..Default::default()
        }
    }
}

§Define helper variables

use o2o::o2o;

struct Person {
    age: i8,
    first_name: String,
    last_name: String
}

#[derive(o2o)]
#[from_owned(Person| vars(first_name: {@.first_name}, last_name: {@.last_name}))]
#[owned_into(Person| vars(first: {"John"}, last: {"Doe"}))]
#[ghosts(first_name: {first.into()}, last_name: {last.into()})]
struct PersonDto {
    age: i8,
    #[ghost({format!("{} {}", first_name, last_name)})]
    full_name: String
}
View generated code
impl ::core::convert::From<Person> for PersonDto {
    fn from(value: Person) -> PersonDto {
        let first_name = value.first_name;
        let last_name = value.last_name;
        PersonDto {
            age: value.age,
            full_name: format!("{} {}", first_name, last_name),
        }
    }
}
impl ::core::convert::Into<Person> for PersonDto {
    fn into(self) -> Person {
        let first = "John";
        let last = "Doe";
        Person {
            age: self.age,
            first_name: first.into(),
            last_name: last.into(),
        }
    }
}

§Quick return

o2o allows you to bypass most of the logic by specifying quick return inline expression following return:

use o2o::o2o;

#[derive(o2o)]
#[owned_into(String| return @.0.to_string())]
#[try_from_owned(String, std::num::ParseIntError)]
struct Wrapper(#[from(@.parse::<i32>()?)]i32);
View generated code
impl ::core::convert::TryFrom<String> for Wrapper {
    type Error = std::num::ParseIntError;
    fn try_from(value: String) -> Result<Wrapper, std::num::ParseIntError> {
        Ok(Wrapper(value.parse::<i32>()?))
    }
}
impl ::core::convert::Into<String> for Wrapper {
    fn into(self) -> String {
        self.0.to_string()
    }
}

Quick returns work well with helper variables:

use o2o::o2o;

#[derive(o2o)]
#[owned_into(i32| vars(hrs: {@.hours as i32}, mns: {@.minutes as i32}, scs: {@.seconds as i32}), 
    return hrs * 3600 + mns * 60 + scs)]
struct Time {
    hours: i8,
    minutes: i8,
    seconds: i8,
}
View generated code
impl ::core::convert::Into<i32> for Time {
    fn into(self) -> i32 {
        let hrs = self.hours as i32;
        let mns = self.minutes as i32;
        let scs = self.seconds as i32;
        hrs * 3600 + mns * 60 + scs
    }
}

§Repeat trait instruction params

#[derive(o2o::o2o)]
// Defining original 'template' instruction
#[from_owned(std::num::ParseIntError| repeat(), return Self(@.to_string()))]
#[from_owned(std::num::ParseFloatError)]
#[from_owned(std::num::TryFromIntError)]
#[from_owned(std::str::ParseBoolError)]
struct MyError(String);
View generated code
impl ::core::convert::From<std::num::ParseIntError> for MyError {
    fn from(value: std::num::ParseIntError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::num::ParseFloatError> for MyError {
    fn from(value: std::num::ParseFloatError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::num::TryFromIntError> for MyError {
    fn from(value: std::num::TryFromIntError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::str::ParseBoolError> for MyError {
    fn from(value: std::str::ParseBoolError) -> MyError {
        Self(value.to_string())
    }
}

Repeated instructions may be skipped or ended:

#[derive(o2o::o2o)]

// Defining original 'template' instruction
#[from_owned(std::num::ParseIntError| repeat(), return Self(@.to_string()))]

// Original instruction is repeated for this conversion
#[from_owned(std::num::ParseFloatError)]

// Do not use (skip) original instruction
#[from_owned(std::num::TryFromIntError| skip_repeat, return Self("Custom TryFromIntError message".into()))]

// Original instruction is repeated for this conversion
#[from_owned(std::str::ParseBoolError)]

// Original instruction is repeated for this conversion
#[from_owned(std::char::ParseCharError)]

// Stop repeating original instruction, define and start repeating a new one
#[from_owned(std::net::AddrParseError| stop_repeat, repeat(), return Self("other".into()))]

// New instruction is repeated for this conversion
#[from_owned(std::io::Error)] 
struct MyError(String);
View generated code
impl ::core::convert::From<std::num::ParseIntError> for MyError {
    fn from(value: std::num::ParseIntError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::num::ParseFloatError> for MyError {
    fn from(value: std::num::ParseFloatError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::num::TryFromIntError> for MyError {
    fn from(value: std::num::TryFromIntError) -> MyError {
        Self("Custom TryFromIntError message".into())
    }
}
impl ::core::convert::From<std::str::ParseBoolError> for MyError {
    fn from(value: std::str::ParseBoolError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::char::ParseCharError> for MyError {
    fn from(value: std::char::ParseCharError) -> MyError {
        Self(value.to_string())
    }
}
impl ::core::convert::From<std::net::AddrParseError> for MyError {
    fn from(value: std::net::AddrParseError) -> MyError {
        Self("other".into())
    }
}
impl ::core::convert::From<std::io::Error> for MyError {
    fn from(value: std::io::Error) -> MyError {
        Self("other".into())
    }
}

§Item attributes (attributes for #[] impl, #[] fn, fn() { #![] })

struct TestDto {
    x: i32
}

#[derive(o2o::o2o)]
#[from_owned(TestDto| 
    impl_attribute(cfg(any(foo, bar))),
    attribute(inline(always)), 
    inner_attribute(allow(unused_variables))
)]
struct Test {
    x: i32,
}
View generated code
#[cfg(any(foo, bar))]
impl ::core::convert::From<TestDto> for Test {
    #[inline(always)]
    fn from(value: TestDto) -> Test {
        #![allow(unused_variables)]
        Test { x: value.x }
    }
}

§Slightly complex example

use o2o::o2o;

struct Employee {
    id: i32,
    first_name: String,
    last_name: String,
    subordinate_of: Box<Employee>,
    subordinates: Vec<Box<Employee>>
}
impl Employee {
    fn get_full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

#[derive(o2o)]
#[map(Employee)]
#[ghosts(
    first_name: {@.get_first_name()},
    last_name: {@.get_last_name()}
)]
struct EmployeeDto {
    #[map(id)]
    employee_id: i32,
    #[ghost(@.get_full_name())]
    full_name: String,

    #[from(Box::new(@.subordinate_of.as_ref().into()))]
    #[into(subordinate_of, Box::new(@.reports_to.as_ref().into()))]
    reports_to: Box<EmployeeDto>,

    #[map(~.iter().map(|p| Box::new(p.as_ref().into())).collect())]
    subordinates: Vec<Box<EmployeeDto>>
}
impl EmployeeDto {
    fn get_first_name(&self) -> String {
        self.full_name.split_whitespace().collect::<Vec<&str>>()[0].into()
    }
    fn get_last_name(&self) -> String {
        self.full_name.split_whitespace().collect::<Vec<&str>>()[1].into()
    }
}
View generated code
impl ::core::convert::From<Employee> for EmployeeDto {
    fn from(value: Employee) -> EmployeeDto {
        EmployeeDto {
            employee_id: value.id,
            full_name: value.get_full_name(),
            reports_to: (|x: &Employee| Box::new(x.subordinate_of.as_ref().into()))(&value),
            subordinates: value.subordinates.iter().map(|p| Box::new(p.as_ref().into())).collect(),
        }
    }
}
impl ::core::convert::From<&Employee> for EmployeeDto {
    fn from(value: &Employee) -> EmployeeDto {
        EmployeeDto {
            employee_id: value.id,
            full_name: value.get_full_name(),
            reports_to: (|x: &Employee| Box::new(x.subordinate_of.as_ref().into()))(value),
            subordinates: value.subordinates.iter().map(|p| Box::new(p.as_ref().into())).collect(),
        }
    }
}
impl ::core::convert::Into<Employee> for EmployeeDto {
    fn into(self) -> Employee {
        Employee {
            id: self.employee_id,
            subordinate_of: (|x: &EmployeeDto| Box::new(x.reports_to.as_ref().into()))(&self),
            subordinates: self.subordinates.iter().map(|p| Box::new(p.as_ref().into())).collect(),
            first_name: (|x: &EmployeeDto| x.get_first_name())(&self),
            last_name: self.get_last_name(),
        }
    }
}
impl ::core::convert::Into<Employee> for &EmployeeDto {
    fn into(self) -> Employee {
        Employee {
            id: self.employee_id,
            subordinate_of: (|x: &EmployeeDto| Box::new(x.reports_to.as_ref().into()))(self),
            subordinates: self.subordinates.iter().map(|p| Box::new(p.as_ref().into())).collect(),
            first_name: (|x: &EmployeeDto| x.get_first_name())(self),
            last_name: self.get_last_name(),
        }
    }
}

§Flatened children

When the instructions are put on the side that contains flatened properties, conversion From<T> and IntoExisting<T> only requires usage of a member level #[child(...)] instruction, which accepts a path to the unflatened field (without the field name itself).

use o2o::o2o;

struct Car {
    number_of_doors: i8,
    vehicle: Vehicle
}
struct Vehicle {
    number_of_seats: i16,
    machine: Machine,
}
struct Machine {
    brand: String,
    year: i16
}

#[derive(o2o)]
#[from_owned(Car)]
#[ref_into_existing(Car)]
struct CarDto {
    number_of_doors: i8,

    #[child(vehicle)]
    number_of_seats: i16,

    #[child(vehicle.machine)]
    #[map_ref(~.clone())]
    brand: String,

    #[child(vehicle.machine)]
    year: i16
}
View generated code
impl ::core::convert::From<Car> for CarDto {
    fn from(value: Car) -> CarDto {
        CarDto {
            number_of_doors: value.number_of_doors,
            number_of_seats: value.vehicle.number_of_seats,
            brand: value.vehicle.machine.brand,
            year: value.vehicle.machine.year,
        }
    }
}
impl o2o::traits::IntoExisting<Car> for &CarDto {
    fn into_existing(self, other: &mut Car) {
        other.number_of_doors = self.number_of_doors;
        other.vehicle.number_of_seats = self.number_of_seats;
        other.vehicle.machine.brand = self.brand.clone();
        other.vehicle.machine.year = self.year;
    }
}

When you need an Into<T> conversion, o2o also expects you to provide types for flatened properties via struct level #[children(...)] instruction:

use o2o::o2o;

struct Car {
    number_of_doors: i8,
    vehicle: Vehicle
}
struct Vehicle {
    number_of_seats: i16,
    machine: Machine,
}
struct Machine {
    brand: String,
    year: i16
}

#[derive(o2o)]
#[owned_into(Car)]
#[children(vehicle: Vehicle, vehicle.machine: Machine)]
struct CarDto {
    number_of_doors: i8,

    #[child(vehicle)]
    number_of_seats: i16,

    #[child(vehicle.machine)]
    brand: String,

    #[child(vehicle.machine)]
    year: i16
}
View generated code
impl ::core::convert::Into<Car> for CarDto {
    fn into(self) -> Car {
        Car {
            number_of_doors: self.number_of_doors,
            vehicle: Vehicle {
                number_of_seats: self.number_of_seats,
                machine: Machine {
                    brand: self.brand,
                    year: self.year,
                },
            },
        }
    }
}

The reverse case, where you have to put o2o insturctions on the side that has field that are being flatened, is slightly tricky:

use o2o::o2o;
use o2o::traits::IntoExisting;

#[derive(o2o)]
#[owned_into(CarDto)]
struct Car {
    number_of_doors: i8,
    #[parent]
    vehicle: Vehicle
}

#[derive(o2o)]
#[owned_into_existing(CarDto)]
struct Vehicle {
    number_of_seats: i16,
    #[parent]
    machine: Machine,
}

#[derive(o2o)]
#[owned_into_existing(CarDto)]
struct Machine {
    brand: String,
    year: i16
}

// CarDto has to implement `Default` trait in this case.
#[derive(Default)]
struct CarDto {
    number_of_doors: i8,
    number_of_seats: i16,
    brand: String,
    year: i16
}
View generated code
impl ::core::convert::Into<CarDto> for Car {
    fn into(self) -> CarDto {
        let mut obj: CarDto = Default::default();
        obj.number_of_doors = self.number_of_doors;
        self.vehicle.into_existing(&mut obj);
        obj
    }
}
impl o2o::traits::IntoExisting<CarDto> for Vehicle {
    fn into_existing(self, other: &mut CarDto) {
        other.number_of_seats = self.number_of_seats;
        self.machine.into_existing(other);
    }
}
impl o2o::traits::IntoExisting<CarDto> for Machine {
    fn into_existing(self, other: &mut CarDto) {
        other.brand = self.brand;
        other.year = self.year;
    }
}

§Tuple structs

use o2o::o2o;

struct TupleEntity(i32, String);

#[derive(o2o)]
#[map_ref(TupleEntity)]
struct TupleEntityDto(i32, #[map_ref(~.clone())] String);
View generated code
impl ::core::convert::From<&TupleEntity> for TupleEntityDto {
    fn from(value: &TupleEntity) -> TupleEntityDto {
        TupleEntityDto(value.0, value.1.clone())
    }
}
impl ::core::convert::Into<TupleEntity> for &TupleEntityDto {
    fn into(self) -> TupleEntity {
        TupleEntity(self.0, self.1.clone())
    }
}

As long as Rust allows following syntax, easy conversion between tuple and named structs can be done if placing o2o instructions on named side:

use o2o::o2o;

struct TupleEntity(i32, String);

#[derive(o2o)]
#[map_ref(TupleEntity)]
struct EntityDto {
    #[map_ref(0)]
    some_int: i32, 
    #[map_ref(1, ~.clone())]
    some_str: String
}
View generated code
impl ::core::convert::From<&TupleEntity> for EntityDto {
    fn from(value: &TupleEntity) -> EntityDto {
        EntityDto {
            some_int: value.0,
            some_str: value.1.clone(),
        }
    }
}
impl ::core::convert::Into<TupleEntity> for &EntityDto {
    fn into(self) -> TupleEntity {
        TupleEntity {
            0: self.some_int,
            1: self.some_str.clone(),
        }
    }
}

§Tuples

use o2o::o2o;

#[derive(o2o)]
#[map_ref((i32, String))]
pub struct Entity{
    #[map(0)]
    int: i32,
    #[map(1, ~.clone())]
    string: String,
}
View generated code
impl ::core::convert::From<&(i32, String)> for Entity {
    fn from(value: &(i32, String)) -> Entity {
        Entity {
            int: value.0,
            string: value.1.clone(),
        }
    }
}
impl ::core::convert::Into<(i32, String)> for &Entity {
    fn into(self) -> (i32, String) {
        (self.int, self.string.clone())
    }
}

§Type hints

By default, o2o will suppose that the struct on the other side is the same kind of type that the original one is. In order to convert between named and tuple structs when you need to place instructions on a tuple side, you`ll need to use Type Hint:

use o2o::o2o;

#[derive(o2o)]
#[map_owned(EntityDto as {})]
struct TupleEntity(#[map(some_int)] i32, #[map(some_str)] String);

struct EntityDto{
    some_int: i32, 
    some_str: String
}
View generated code
impl ::core::convert::From<EntityDto> for TupleEntity {
    fn from(value: EntityDto) -> TupleEntity {
        TupleEntity(value.some_int, value.some_str)
    }
}
impl ::core::convert::Into<EntityDto> for TupleEntity {
    fn into(self) -> EntityDto {
        EntityDto {
            some_int: self.0,
            some_str: self.1,
        }
    }
}

§Lifetimes

When creating reference implementations including lifetimes, such as

#[from_ref(Entity)]
pub struct EntityDto<'a, 'b> 

or

#[ref_into(EntityDto<'a, 'b>)]
pub struct Entity

a reference lifetime may need to be introduced. o2o is able to recognize such cases.

use o2o::o2o;

pub struct Entity {
    pub some_a: String,
    pub some_b: String,
}

#[derive(o2o)]
#[from_ref(Entity)]
pub struct EntityDto<'a, 'b> {
    #[from(~.as_str())]
    pub some_a: &'a str,
    #[from(~.as_str())]
    pub some_b: &'b str,
}
View generated code
// o2o will generate additional lifetime 'o2o here
impl<'a, 'b, 'o2o: 'a + 'b> ::core::convert::From<&'o2o Entity> for EntityDto<'a, 'b> {
    fn from(value: &'o2o Entity) -> EntityDto<'a, 'b> {
        EntityDto {
          some_a: value.some_a.as_str(),
          some_b: value.some_b.as_str()
        }
    }
}

Mirror scenario:

use o2o::o2o;

#[derive(o2o)]
#[ref_into(EntityDto<'a, 'b>)]
pub struct Entity {
    #[into(~.as_str())]
    pub some_a: String,
    #[into(~.as_str())]
    pub some_b: String,
}

pub struct EntityDto<'a, 'b> {
    pub some_a: &'a str,
    pub some_b: &'b str,
}
View generated code
// o2o will generate additional lifetime 'o2o here
impl<'a, 'b, 'o2o: 'a + 'b> ::core::convert::Into<EntityDto<'a, 'b>> for &'o2o Entity {
    fn into(self) -> EntityDto<'a, 'b> {
        EntityDto {
          some_a: self.some_a.as_str(),
          some_b: self.some_b.as_str()
        }
    }
}

§Generics

use o2o::o2o;

struct Entity<T> {
    some_int: i32,
    something: T,
}

#[derive(o2o)]
#[map_owned(Entity::<f32>)]
struct EntityDto {
    some_int: i32,
    something: f32
}
View generated code
impl ::core::convert::From<Entity<f32>> for EntityDto {
    fn from(value: Entity<f32>) -> EntityDto {
        EntityDto {
            some_int: value.some_int,
            something: value.something,
        }
    }
}
impl ::core::convert::Into<Entity<f32>> for EntityDto {
    fn into(self) -> Entity<f32> {
        Entity::<f32> {
            some_int: self.some_int,
            something: self.something,
        }
    }
}

§Where clauses

use o2o::o2o;

struct Child<T> {
    child_int: i32,
    something: T,
}

#[derive(o2o)]
#[map_owned(Child::<T>)]
#[where_clause(T: Clone)]
struct ChildDto<T> {
    child_int: i32,
    #[map(something, ~.clone())]
    stuff: T,
}
View generated code
impl<T> ::core::convert::From<Child<T>> for ChildDto<T> where T: Clone, {
    fn from(value: Child<T>) -> ChildDto<T> {
        ChildDto {
            child_int: value.child_int,
            stuff: value.something.clone(),
        }
    }
}
impl<T> ::core::convert::Into<Child<T>> for ChildDto<T> where T: Clone, {
    fn into(self) -> Child<T> {
        Child::<T> {
            child_int: self.child_int,
            something: self.stuff.clone(),
        }
    }
}

§Mapping to multiple structs

use o2o::o2o;

struct Person {
    full_name: String,
    age: i32,
    country: String,
}

struct PersonModel {
    full_name: String,
    age: i32,
    place_of_birth: String,
}

#[derive(o2o)]
#[ref_into(Person)]
#[ref_into(PersonModel)]
struct PersonDto {
    // 'Default' member level instruction applies to all types
    #[into(full_name, ~.clone())]
    name: String,
    age: i32,
    // 'Dedicated' member level instruction applies to a specific type only
    #[into(Person| country, ~.clone())]
    #[into(PersonModel| ~.clone())]
    place_of_birth: String,
}
View generated code
impl ::core::convert::Into<Person> for &PersonDto {
    fn into(self) -> Person {
        Person {
            full_name: self.name.clone(),
            age: self.age,
            country: self.place_of_birth.clone(),
        }
    }
}
impl ::core::convert::Into<PersonModel> for &PersonDto {
    fn into(self) -> PersonModel {
        PersonModel {
            full_name: self.name.clone(),
            age: self.age,
            place_of_birth: self.place_of_birth.clone(),
        }
    }
}

§Avoiding proc macro attribute name collisions (alternative instruction syntax)

o2o proc macro declares a lot of attributes, some of which have pretty broad meaning (e.g. from, into, map, child, parent etc.), so if you have to use it with some other proc macro, there is a chance that these attributes can collide and it would not be clear to what proc macro they should apply. For this scenario, o2o supports two alternative syntaxes (syntacies?):

Below, all three variants of o2o proc macro application will produce the same generated code:

use o2o::o2o;

struct Entity {
    some_int: i32,
    val: i16,
    str: String
}
// =====================================================================
#[derive(o2o)]
#[from(Entity)]
#[try_into(Entity, std::num::ParseIntError)]
struct EntityDto1 {
    some_int: i32,
    #[from(~.to_string())]
    #[into(~.parse::<i16>()?)]
    val: String,
    #[map_ref(~.clone())] 
    str: String
}
// =====================================================================
#[derive(o2o)]
#[o2o(from(Entity))]
#[o2o(try_into(Entity, std::num::ParseIntError))]
struct EntityDto2 {
    some_int: i32,
    #[o2o(from(~.to_string()))]
    #[o2o(into(~.parse::<i16>()?))]
    val: String,
    #[o2o(map_ref(~.clone()))] 
    str: String
}
// =====================================================================
#[derive(o2o)]
#[o2o(
    from(Entity),
    try_into(Entity, std::num::ParseIntError)
)]
struct EntityDto3 {
    some_int: i32,
    #[o2o(
        from(~.to_string()),
        try_into(~.parse::<i16>()?),
    )]
    val: String,
    #[o2o(map_ref(~.clone()))] 
    str: String
}
// =====================================================================

This syntax applies to all supported struct and member level instructions.

§Additional o2o instruction available via #[o2o(...)] syntax

§Primitive type conversions
use o2o::o2o;

struct Entity {
    some_int: i32,
    some_float: f32
}

#[derive(o2o)]
#[o2o(map_ref(Entity))]
struct EntityDto {
    #[o2o(as_type(i32))]
    some_int: i16,
    #[o2o(as_type(some_float, f32))]
    another_int: i16
}
View generated code
impl ::core::convert::From<&Entity> for EntityDto {
    fn from(value: &Entity) -> EntityDto {
        EntityDto {
            some_int: value.some_int as i16,
            another_int: value.some_float as i16,
        }
    }
}
impl ::core::convert::Into<Entity> for &EntityDto {
    fn into(self) -> Entity {
        Entity {
            some_int: self.some_int as i32,
            some_float: self.another_int as f32,
        }
    }
}

This will work with all types that support ‘as’ conversion.

§Repeat member instructions
use o2o::o2o;

struct Car {
    number_of_doors: i8,
    vehicle: Vehicle
}
struct Vehicle {
    number_of_seats: i16,
    can_fly: bool,
    needs_driver: bool,
    horsepower: i32,
    top_speed: f32,
    machine: Machine,
}
struct Machine {
    id: i32,
    brand: String,
    year: i16,
    weight: f32,
    length: f32,
    width: f32,
    height: f32,
}

#[derive(o2o)]
#[map_ref(Car)]
#[children(vehicle: Vehicle, vehicle.machine: Machine)]
#[ghosts(vehicle.machine@id: {321})]
struct CarDto {
    number_of_doors: i8,

    // #[o2o(repeat)] will repeat all instructions for this member to the following members, 
    // until there is a #[o2o(stop_repeat)] or the members run out.
    #[o2o(repeat)] #[child(vehicle)]
    number_of_seats: i16,
    can_fly: bool,
    needs_driver: bool,
    horsepower: i32,
    top_speed: f32,
    #[o2o(stop_repeat)]

    // You can also specify what specific types of instructions to repeat
    // (supported values are 'map', 'child', 'parent', 'ghost')
    #[o2o(repeat(child))] #[child(vehicle.machine)]
    #[map(~.clone())]
    brand: String,
    year: i16,
    weight: f32,
    length: f32,
    width: f32,
    height: f32,
    #[o2o(stop_repeat)]

    #[o2o(repeat)] #[ghost({123})]
    useless_param: i32,
    useless_param_2: i32,
    useless_param_3: i32,
}
View generated code
impl ::core::convert::From<&Car> for CarDto {
    fn from(value: &Car) -> CarDto {
        CarDto {
            number_of_doors: value.number_of_doors,
            number_of_seats: value.vehicle.number_of_seats,
            can_fly: value.vehicle.can_fly,
            needs_driver: value.vehicle.needs_driver,
            horsepower: value.vehicle.horsepower,
            top_speed: value.vehicle.top_speed,
            brand: value.vehicle.machine.brand.clone(),
            year: value.vehicle.machine.year,
            weight: value.vehicle.machine.weight,
            length: value.vehicle.machine.length,
            width: value.vehicle.machine.width,
            height: value.vehicle.machine.height,
            useless_param: 123,
            useless_param_2: 123,
            useless_param_3: 123,
        }
    }
}
impl ::core::convert::Into<Car> for &CarDto {
    fn into(self) -> Car {
        Car {
            number_of_doors: self.number_of_doors,
            vehicle: Vehicle {
                number_of_seats: self.number_of_seats,
                can_fly: self.can_fly,
                needs_driver: self.needs_driver,
                horsepower: self.horsepower,
                top_speed: self.top_speed,
                machine: Machine {
                    brand: self.brand.clone(),
                    year: self.year,
                    weight: self.weight,
                    length: self.length,
                    width: self.width,
                    height: self.height,
                    id: 321,
                },
            },
        }
    }
}
§‘Permeating’ repeat for enum variant fields

If you want repeat to be carried on on the fields of the following variants, you can use permeate() inside repeat instruction:

enum Enum {
    Var1 { field: i32, field_2: i32 },
    Var2 { field_3: i32 },
    Var3 { field_4: i32 },
    Var4 { field_5: i32 },
    Var5 { str: &'static str },
}

#[derive(o2o::o2o)]
#[map_owned(Enum)]
enum EnumDto {
    Var1 {
        #[o2o(repeat(permeate()))] 
        #[from(~ * 2)] 
        #[into(~ / 2)] 

        field: i32,
        field_2: i32
     },
    Var2 { field_3: i32 },
    Var3 { field_4: i32 },
    Var4 { field_5: i32 },
    Var5 { #[o2o(stop_repeat)] str: &'static str },
}
View generated code
impl ::core::convert::From<Enum> for EnumDto {
    fn from(value: Enum) -> EnumDto {
        match value {
            Enum::Var1 { field, field_2 } => EnumDto::Var1 {
                field: field * 2,
                field_2: field_2 * 2,
            },
            Enum::Var2 { field_3 } => EnumDto::Var2 {
                field_3: field_3 * 2,
            },
            Enum::Var3 { field_4 } => EnumDto::Var3 {
                field_4: field_4 * 2,
            },
            Enum::Var4 { field_5 } => EnumDto::Var4 {
                field_5: field_5 * 2,
            },
            Enum::Var5 { str } => EnumDto::Var5 { str: str },
        }
    }
}
impl ::core::convert::Into<Enum> for EnumDto {
    fn into(self) -> Enum {
        match self {
            EnumDto::Var1 { field, field_2 } => Enum::Var1 {
                field: field / 2,
                field_2: field_2 / 2,
            },
            EnumDto::Var2 { field_3 } => Enum::Var2 {
                field_3: field_3 / 2,
            },
            EnumDto::Var3 { field_4 } => Enum::Var3 {
                field_4: field_4 / 2,
            },
            EnumDto::Var4 { field_5 } => Enum::Var4 {
                field_5: field_5 / 2,
            },
            EnumDto::Var5 { str } => Enum::Var5 { str: str },
        }
    }
}

§Enum Examples

§Different variant name

pub enum Sort {
    ASC,
    DESC,
    None
}

#[derive(o2o::o2o)]
#[map_owned(Sort)]
pub enum SortDto {
    #[map(ASC)] Ascending,
    #[map(DESC)] Descending,
    None
}
View generated code
impl ::core::convert::From<Sort> for SortDto {
    fn from(value: Sort) -> SortDto {
        match value {
            Sort::ASC => SortDto::Ascending,
            Sort::DESC => SortDto::Descending,
            Sort::None => SortDto::None,
        }
    }
}
impl ::core::convert::Into<Sort> for SortDto {
    fn into(self) -> Sort {
        match self {
            SortDto::Ascending => Sort::ASC,
            SortDto::Descending => Sort::DESC,
            SortDto::None => Sort::None,
        }
    }
}

§Different enum variant field names and types

enum EnumWithData {
    Item1(i32, i16),
    Item2 { str: String, i: i32 },
}

#[derive(o2o::o2o)]
#[from_owned(EnumWithData)]
#[owned_try_into(EnumWithData, std::num::ParseIntError)]
enum EnumWithDataDto {
    Item1(
        #[from(~.to_string())] 
        #[into(~.parse::<i32>()?)]
        String, 
        i16
    ),
    Item2 {
        str: String,
        #[from(i, ~.to_string())] 
        #[into(i, ~.parse::<i32>()?)]
        i_str: String 
    },
}
View generated code
impl ::core::convert::From<EnumWithData> for EnumWithDataDto {
    fn from(value: EnumWithData) -> EnumWithDataDto {
        match value {
            EnumWithData::Item1(f0, f1) => EnumWithDataDto::Item1(f0.to_string(), f1),
            EnumWithData::Item2 { str, i } => EnumWithDataDto::Item2 {
                str: str,
                i_str: i.to_string(),
            },
        }
    }
}
impl ::core::convert::TryInto<EnumWithData> for EnumWithDataDto {
    type Error = std::num::ParseIntError;
    fn try_into(self) -> Result<EnumWithData, std::num::ParseIntError> {
        Ok(match self {
            EnumWithDataDto::Item1(f0, f1) => EnumWithData::Item1(f0.parse::<i32>()?, f1),
            EnumWithDataDto::Item2 { str, i_str } => EnumWithData::Item2 {
                str: str,
                i: i_str.parse::<i32>()?,
            },
        })
    }
}

Alternatively, this can be done this way:

enum EnumWithData {
    Item1(i32, i16),
    Item2 { str: String, i: i32 },
}

#[derive(o2o::o2o)]
#[from_owned(EnumWithData)]
#[owned_try_into(EnumWithData, std::num::ParseIntError)]
enum EnumWithDataDto {
    // When applied to enum variants, ~ replaces 'RightSideEnum::VariantName'
    #[from(~(f0.to_string(), f1))] // ~ is 'EnumWithDataDto::Item1'
    #[into(~(f0.parse::<i32>()?, f1))] // ~ is 'EnumWithData::Item1'
    Item1(String, i16),
    #[from(~{ str, i_str: i.to_string()})] 
    #[into(~{ str, i: i_str.parse::<i32>()? })]
    Item2 { str: String, #[map(i)]i_str: String },
}

This example will produce exactly the same code as the example above.

§Enum variant type hint

Mapping to a unit enum variant:

#[derive(o2o::o2o)]
#[owned_into(EnumDto)]
enum Enum {
    Var1,
    #[type_hint(as Unit)]
    Var2(i32, String),
    #[type_hint(as Unit)]
    Var3 {_field: i32, _str_field: String}
}

enum EnumDto {
    Var1,
    Var2,
    Var3
}
View generated code
impl ::core::convert::Into<EnumDto> for Enum {
    fn into(self) -> EnumDto {
        match self {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2(f0, f1) => EnumDto::Var2,
            Enum::Var3 { _field, _str_field } => EnumDto::Var3,
        }
    }
}

Reversed example:

enum Enum {
    Var1,
    Var2(i32, String),
    Var3 { _field: i32, _str_field: String }
}

#[derive(o2o::o2o)]
#[from(Enum)]
enum EnumDto {
    Var1,
    #[type_hint(as ())] Var2,
    #[type_hint(as {})] Var3
}
View generated code
impl ::core::convert::From<Enum> for EnumDto {
    fn from(value: Enum) -> EnumDto {
        match value {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2(..) => EnumDto::Var2,
            Enum::Var3 { .. } => EnumDto::Var3,
        }
    }
}

Mapping between struct and tuple variants:

#[derive(o2o::o2o)]
#[map_owned(EnumDto)]
enum Enum {
    Var1,

    #[type_hint(as ())]
    Var2 { field: i32 },

    #[type_hint(as {})]
    Var3(
        #[map_owned(str_field)]
        String
    )
}

enum EnumDto {
    Var1,
    Var2(i32),
    Var3 {str_field: String}
}
View generated code
impl ::core::convert::From<EnumDto> for Enum {
    fn from(value: EnumDto) -> Enum {
        match value {
            EnumDto::Var1 => Enum::Var1,
            EnumDto::Var2(f0) => Enum::Var2 { field: f0 },
            EnumDto::Var3 { str_field } => Enum::Var3(str_field),
        }
    }
}
impl ::core::convert::Into<EnumDto> for Enum {
    fn into(self) -> EnumDto {
        match self {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2 { field } => EnumDto::Var2(field),
            Enum::Var3(f0) => EnumDto::Var3 { str_field: f0 },
        }
    }
}

§Enum ghost variants

enum Enum {
    Var1,
    Var2(i32, String),
}

#[derive(o2o::o2o)]
#[from_owned(Enum)]
#[owned_try_into(Enum, String)]
enum EnumDto {
    Var1,
    Var2(i32, String),
    #[ghost({Err(format!("unknown: {}", _str_field))?})]
    Var3 { _field: i32, _str_field: String }
}
View generated code
impl ::core::convert::From<Enum> for EnumDto {
    fn from(value: Enum) -> EnumDto {
        match value {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2(f0, f1) => EnumDto::Var2(f0, f1),
        }
    }
}
impl ::core::convert::TryInto<Enum> for EnumDto {
    type Error = String;
    fn try_into(self) -> Result<Enum, String> {
        Ok(match self {
            EnumDto::Var1 => Enum::Var1,
            EnumDto::Var2(f0, f1) => Enum::Var2(f0, f1),
            EnumDto::Var3 { _field, _str_field } => Err(format!("unknown: {}", _str_field))?,
        })
    }
}

Reverse case:

#[derive(o2o::o2o)]
#[try_from_owned(EnumDto, String)]
#[owned_into(EnumDto)]
#[ghosts(Var3 { _str_field, .. }: {Err(format!("Unknown: {}", _str_field))?})]
enum Enum {
    Var1,
    Var2(i32, String),
}

enum EnumDto {
    Var1,
    Var2(i32, String),
    Var3 { _field: i32, _str_field: String }
}
View generated code
impl ::core::convert::TryFrom<EnumDto> for Enum {
    type Error = String;
    fn try_from(value: EnumDto) -> Result<Enum, String> {
        Ok(match value {
            EnumDto::Var1 => Enum::Var1,
            EnumDto::Var2(f0, f1) => Enum::Var2(f0, f1),
            EnumDto::Var3 { _str_field, .. } => Err(format!("Unknown: {}", _str_field))?,
        })
    }
}
impl ::core::convert::Into<EnumDto> for Enum {
    fn into(self) -> EnumDto {
        match self {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2(f0, f1) => EnumDto::Var2(f0, f1),
        }
    }
}

§Enum variant ghost fields

Skipping fields and providing default values:

#[derive(o2o::o2o)]
#[map_owned(EnumDto)]
enum Enum {
    Var1,
    Var2 {
        field: i32,
        #[ghost(321.0)]
        _f: f32,
    },
    Var3(
        i32,
        #[ghost({123.0})]
        f32,
    )
}

enum EnumDto {
    Var1,
    Var2 {field: i32},
    Var3(i32),
}
View generated code
impl ::core::convert::From<EnumDto> for Enum {
    fn from(value: EnumDto) -> Enum {
        match value {
            EnumDto::Var1 => Enum::Var1,
            EnumDto::Var2 { field } => Enum::Var2 {
                field: field,
                _f: 321.0,
            },
            EnumDto::Var3(f0) => Enum::Var3(f0, 123.0),
        }
    }
}
impl ::core::convert::Into<EnumDto> for Enum {
    fn into(self) -> EnumDto {
        match self {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2 { field, _f } => EnumDto::Var2 { field: field },
            Enum::Var3(f0, f1) => EnumDto::Var3(f0),
        }
    }
}

Missing fields and default values:

#[derive(o2o::o2o)]
#[map_owned(EnumDto)]
enum Enum {
    Var1,
    #[ghosts(f: {123.0})]
    Var2 {
        field: i32,
    },
    #[ghosts(1: {321.0})]
    Var3(
        i32,
    )
}

enum EnumDto {
    Var1,
    Var2 {field: i32, f: f32},
    Var3(i32, f32),
}
View generated code
impl ::core::convert::From<EnumDto> for Enum {
    fn from(value: EnumDto) -> Enum {
        match value {
            EnumDto::Var1 => Enum::Var1,
            EnumDto::Var2 { field, f } => Enum::Var2 { field: field },
            EnumDto::Var3(f0, f1) => Enum::Var3(f0),
        }
    }
}
impl ::core::convert::Into<EnumDto> for Enum {
    fn into(self) -> EnumDto {
        match self {
            Enum::Var1 => EnumDto::Var1,
            Enum::Var2 { field } => EnumDto::Var2 {
                field: field,
                f: 123.0,
            },
            Enum::Var3(f0) => EnumDto::Var3(f0, 321.0),
        }
    }
}

§Mapping to primitive types

§Using literals

Literals can be used to produce both From and Into implementations:

#[derive(o2o::o2o)]
#[map_owned(i32| _ => panic!("Not supported"))]
enum HttpStatus {
    #[literal(200)]Ok,
    #[literal(201)]Created,
    #[literal(401)]Unauthorized,
    #[literal(403)]Forbidden,
    #[literal(404)]NotFound,
    #[literal(500)]InternalError
}

type StaticStr = &'static str;

#[derive(o2o::o2o)]
#[map_owned(StaticStr| _ => todo!())]
enum Animal {
    #[literal("🐶")] Dog,
    #[literal("🐱")] Cat,
    #[literal("🐵")] Monkey
}
View generated code
impl ::core::convert::From<i32> for HttpStatus {
    fn from(value: i32) -> HttpStatus {
        match value {
            200 => HttpStatus::Ok,
            201 => HttpStatus::Created,
            401 => HttpStatus::Unauthorized,
            403 => HttpStatus::Forbidden,
            404 => HttpStatus::NotFound,
            500 => HttpStatus::InternalError,
            _ => panic!("Not supported"),
        }
    }
}
impl ::core::convert::Into<i32> for HttpStatus {
    fn into(self) -> i32 {
        match self {
            HttpStatus::Ok => 200,
            HttpStatus::Created => 201,
            HttpStatus::Unauthorized => 401,
            HttpStatus::Forbidden => 403,
            HttpStatus::NotFound => 404,
            HttpStatus::InternalError => 500,
        }
    }
}

impl ::core::convert::From<StaticStr> for Animal {
    fn from(value: StaticStr) -> Animal {
        match value {
            "🐶" => Animal::Dog,
            "🐱" => Animal::Cat,
            "🐵" => Animal::Monkey,
            _ => todo!(),
        }
    }
}
impl ::core::convert::Into<StaticStr> for Animal {
    fn into(self) -> StaticStr {
        match self {
            Animal::Dog => "🐶",
            Animal::Cat => "🐱",
            Animal::Monkey => "🐵",
        }
    }
}
§Using patterns

Patterns are only used to produce From implementations:

#[derive(o2o::o2o)]
#[from_owned(i32| _ => panic!())]
enum HttpStatusFamily {
    #[pattern(100..=199)] Information,
    #[pattern(200..=299)] Success,
    #[pattern(300..=399)] Redirection,
    #[pattern(400..=499)] ClientError,
    #[pattern(500..=599)] ServerError,
}

type StaticStr = &'static str;

#[derive(o2o::o2o)]
#[from_owned(StaticStr| _ => todo!())]
enum AnimalKind {
    #[pattern("🐶" | "🐱" | "🐵")]
    Mammal,

    #[pattern("🐟")] 
    Fish,
    
    #[pattern("🐛" | "🐜")]
    Insect
}
View generated code
impl ::core::convert::From<i32> for HttpStatusFamily {
    fn from(value: i32) -> HttpStatusFamily {
        match value {
            100..=199 => HttpStatusFamily::Information,
            200..=299 => HttpStatusFamily::Success,
            300..=399 => HttpStatusFamily::Redirection,
            400..=499 => HttpStatusFamily::ClientError,
            500..=599 => HttpStatusFamily::ServerError,
            _ => panic!(),
        }
    }
}

impl ::core::convert::From<StaticStr> for AnimalKind {
    fn from(value: StaticStr) -> AnimalKind {
        match value {
            "🐶" | "🐱" | "🐵" => AnimalKind::Mammal,
            "🐟" => AnimalKind::Fish,
            "🐛" | "🐜" => AnimalKind::Insect,
            _ => todo!(),
        }
    }
}
§Using literals and patterns together
#[derive(o2o::o2o)]
#[map_owned(i32)]
enum HttpStatus {
    #[literal(200)] Ok,
    #[literal(404)] NotFound,
    #[literal(500)] InternalError,
    #[pattern(_)] #[into({f0})] Other(#[from(@)] i32)
}

type StaticStr = &'static str;

#[derive(o2o::o2o)]
#[map_owned(StaticStr)]
enum Animal {
    #[literal("🐶")] Dog,
    #[literal("🐱")] Cat,
    #[literal("🐵")] Monkey,
    #[pattern(_)] #[into({name})] Other{ #[from(@)] name: StaticStr }
}
View generated code
impl ::core::convert::From<i32> for HttpStatus {
    fn from(value: i32) -> HttpStatus {
        match value {
            200 => HttpStatus::Ok,
            404 => HttpStatus::NotFound,
            500 => HttpStatus::InternalError,
            _ => HttpStatus::Other(value),
        }
    }
}
impl ::core::convert::Into<i32> for HttpStatus {
    fn into(self) -> i32 {
        match self {
            HttpStatus::Ok => 200,
            HttpStatus::NotFound => 404,
            HttpStatus::InternalError => 500,
            HttpStatus::Other(f0) => f0,
        }
    }
}

impl ::core::convert::From<StaticStr> for Animal {
    fn from(value: StaticStr) -> Animal {
        match value {
            "🐶" => Animal::Dog,
            "🐱" => Animal::Cat,
            "🐵" => Animal::Monkey,
            _ => Animal::Other { name: value },
        }
    }
}
impl ::core::convert::Into<StaticStr> for Animal {
    fn into(self) -> StaticStr {
        match self {
            Animal::Dog => "🐶",
            Animal::Cat => "🐱",
            Animal::Monkey => "🐵",
            Animal::Other { name } => name,
        }
    }
}
§Fallible conversions to primitive types

#[literal(...)] and #[pattern(...)] work well with fallible conversions:

type StaticStr = &'static str;

#[derive(o2o::o2o)]
#[try_map_owned(i32, StaticStr| _ => Err("Unrepresentable")?)]
enum HttpStatus {
    #[literal(200)]Ok,
    #[literal(201)]Created,
    #[literal(401)]Unauthorized,
    #[literal(403)]Forbidden,
    #[literal(404)]NotFound,
    #[literal(500)]InternalError
}

#[derive(o2o::o2o)]
#[try_from_owned(i32, StaticStr| _ => Err("Unrepresentable")?)]
enum HttpStatusFamily {
    #[pattern(100..=199)] Information,
    #[pattern(200..=299)] Success,
    #[pattern(300..=399)] Redirection,
    #[pattern(400..=499)] ClientError,
    #[pattern(500..=599)] ServerError,
}
View generated code
impl ::core::convert::TryFrom<i32> for HttpStatus {
    type Error = StaticStr;
    fn try_from(value: i32) -> Result<HttpStatus, StaticStr> {
        Ok(match value {
            200 => HttpStatus::Ok,
            201 => HttpStatus::Created,
            401 => HttpStatus::Unauthorized,
            403 => HttpStatus::Forbidden,
            404 => HttpStatus::NotFound,
            500 => HttpStatus::InternalError,
            _ => Err("Unrepresentable")?,
        })
    }
}
impl ::core::convert::TryInto<i32> for HttpStatus {
    type Error = StaticStr;
    fn try_into(self) -> Result<i32, StaticStr> {
        Ok(match self {
            HttpStatus::Ok => 200,
            HttpStatus::Created => 201,
            HttpStatus::Unauthorized => 401,
            HttpStatus::Forbidden => 403,
            HttpStatus::NotFound => 404,
            HttpStatus::InternalError => 500,
        })
    }
}

impl ::core::convert::TryFrom<i32> for HttpStatusFamily {
  type Error = StaticStr;
  fn try_from(value: i32) -> Result<HttpStatusFamily, StaticStr> {
      Ok(match value {
          100..=199 => HttpStatusFamily::Information,
          200..=299 => HttpStatusFamily::Success,
          300..=399 => HttpStatusFamily::Redirection,
          400..=499 => HttpStatusFamily::ClientError,
          500..=599 => HttpStatusFamily::ServerError,
          _ => Err("Unrepresentable")?,
      })
  }
}

§Contributions

All issues, questions, pull requests are extremely welcome.

§License

Licensed under either an Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Modules§

Derive Macros§

  • Object to Object mapper for Rust