ultimate 0.1.0

Rust libraries
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

/// Convenience macro rules to generate default CRUD functions for a Bmc/Entity.
/// Note: If custom functionality is required, use the code below as foundational
///       code for the custom implementations.
#[macro_export]
macro_rules! generate_common_bmc_fns {
	(
		Bmc: $struct_name:ident,
		Entity: $entity:ty,
		$(ForCreate: $for_create:ty,)?
		$(ForUpdate: $for_update:ty,)?
		$(Filter: $filter:ty,)?
	) => {
		impl $struct_name {
			$(
				pub async fn create(
					ctx: &Ctx,
					mm: &ModelManager,
					entity_c: $for_create,
				) -> Result<i64> {
					base::create::<Self, _>(ctx, mm, entity_c).await
				}

				pub async fn create_many(
					ctx: &Ctx,
					mm: &ModelManager,
					entity_c: Vec<$for_create>,
				) -> Result<Vec<i64>> {
					base::create_many::<Self, _>(ctx, mm, entity_c).await
				}
			)?

				pub async fn get(
					ctx: &Ctx,
					mm: &ModelManager,
					id: i64,
				) -> Result<$entity> {
					base::get::<Self, _>(ctx, mm, id).await
				}

			$(
				pub async fn first(
					ctx: &Ctx,
					mm: &ModelManager,
					filter: Option<Vec<$filter>>,
					list_options: Option<ListOptions>,
				) -> Result<Option<$entity>> {
					base::first::<Self, _, _>(ctx, mm, filter, list_options).await
				}

				pub async fn list(
					ctx: &Ctx,
					mm: &ModelManager,
					filter: Option<Vec<$filter>>,
					list_options: Option<ListOptions>,
				) -> Result<Vec<$entity>> {
					base::list::<Self, _, _>(ctx, mm, filter, list_options).await
				}

				pub async fn count(
					ctx: &Ctx,
					mm: &ModelManager,
					filter: Option<Vec<$filter>>,
				) -> Result<i64> {
					base::count::<Self, _>(ctx, mm, filter).await
				}
			)?

			$(
				pub async fn update(
					ctx: &Ctx,
					mm: &ModelManager,
					id: i64,
					entity_u: $for_update,
				) -> Result<()> {
					base::update::<Self, _>(ctx, mm, id, entity_u).await
				}
			)?

				pub async fn delete(
					ctx: &Ctx,
					mm: &ModelManager,
					id: i64,
				) -> Result<()> {
					base::delete::<Self>(ctx, mm, id).await
				}

				pub async fn delete_many(
					ctx: &Ctx,
					mm: &ModelManager,
					ids: Vec<i64>,
				) -> Result<u64> {
					base::delete_many::<Self>(ctx, mm, ids).await
				}
		}
	};
}