gorm 0.1.4

An orm that is simple to use and prevents all mistakes at compile time
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

use std::marker::PhantomData;

use crate::{sql::Table, util::TypesNotEqual};

/// A typed cons list of tables from which columns can be used in an sql
/// expression.
pub trait SelectableTables {}

/// A marker trait which indicates that a list of selectable tables contains
/// some table.
pub trait SelectableTablesContains<T: Table>: SelectableTables {}

/// A cons item in the selectable tables cons list.
pub struct SelectableTablesCons<T: Table, N: SelectableTables>(PhantomData<T>, PhantomData<N>);

// A table is a `SelectableTables`, and as such, it contains itself
impl<T: Table> SelectableTables for T {}
impl<T: Table> SelectableTablesContains<T> for T {}

// a cons item is a `SelectableTables`
impl<T: Table, N: SelectableTables> SelectableTables for SelectableTablesCons<T, N> {}

// a cons list item contains the Table it holds, and everything else that its
// next holds which is not the same as the table it holds.
impl<T: Table, N: SelectableTables> SelectableTablesContains<T> for SelectableTablesCons<T, N> {}
impl<T: Table, N: SelectableTables, InnerT: Table> SelectableTablesContains<InnerT>
    for SelectableTablesCons<T, N>
where
    N: SelectableTablesContains<InnerT>,
    (T, InnerT): TypesNotEqual,
{
}

/// A trait used to combine 2 selectable tables types.
pub trait CombineSelectableTables<CombineWith: SelectableTables> {
    type Combined: SelectableTables;
}

impl<T: Table + SelectableTables, CombineWith: SelectableTables>
    CombineSelectableTables<CombineWith> for T
{
    type Combined = SelectableTablesCons<T, CombineWith>;
}

/// A type alias which represents the result of combining 2 types which
/// implement the [`SelectableTables`] trait into a single type which implements
/// that trait.
pub type CombinedSelectableTables<A, B> = <A as CombineSelectableTables<B>>::Combined;

impl<
    T: Table,
    N: SelectableTables + CombineSelectableTables<CombineWith>,
    CombineWith: SelectableTables,
> CombineSelectableTables<CombineWith> for SelectableTablesCons<T, N>
{
    type Combined = SelectableTablesCons<T, CombinedSelectableTables<N, CombineWith>>;
}