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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
mod one;
mod three;
mod two;
use crate::cmap::{CMap3, DartIdType, SewError};
use crate::geometry::CoordsFloat;
use crate::stm::{Transaction, TransactionClosureResult, atomically_with_err};
/// # **Sew operations**
impl<T: CoordsFloat> CMap3<T> {
/// `I`-sew operator.
///
/// # Description
///
/// This operation corresponds to:
/// - coherently linking two darts via their *β* images,
/// - merging the attributes associated to their respective original `I`-cells.
///
/// For a thorough explanation of this operation, its hypothesis & consequences, refer
/// to the [user guide][UG].
///
/// [UG]: https://lihpc-computational-geometry.github.io/honeycomb/user-guide/definitions/sew.html
///
/// # Arguments
///
/// - `const I: u8` -- Sew dimension.
/// - `t: &mut Transaction` -- Transaction associated to the operation.
/// - `ld: DartIdType` -- First dart ID.
/// - `rd: DartIdType` -- Second dart ID.
///
/// # Errors
///
/// This variant will abort the sew operation and raise an error if:
/// - the transaction cannot be completed,
/// - one (or more) attribute merge fails,
/// - for `I == 3`: orientation is inconsistent.
///
/// The returned error can be used in conjunction with transaction control to avoid any
/// modifications in case of failure at attribute level. The user can then choose to retry or
/// abort as he wishes using `Transaction::with_control`.
///
/// # Panics
///
/// The method may panic if:
/// - `I >= 4` or `I == 0`,
/// - the two darts are not `I`-sewable.
pub fn sew_tx<const I: u8>(
&self,
t: &mut Transaction,
ld: DartIdType,
rd: DartIdType,
) -> TransactionClosureResult<(), SewError> {
// these assertions + match on a const are optimized away
assert!(I < 4);
assert_ne!(I, 0);
match I {
1 => self.one_sew_tx(t, ld, rd),
2 => self.two_sew_tx(t, ld, rd),
3 => self.three_sew_tx(t, ld, rd),
_ => unreachable!(),
}
}
/// `I`-unsew operator.
///
/// # Description
///
/// This operation corresponds to:
/// - unlinking two darts by resetting their *β* images,
/// - splitting the attributes associated to the original `I`-cell.
///
/// For a thorough explanation of this operation, its hypothesis & consequences, refer
/// to the [user guide][UG].
///
/// [UG]: https://lihpc-computational-geometry.github.io/honeycomb/user-guide/definitions/sew.html
///
/// # Arguments
///
/// - `const I: u8` -- Unsew dimension.
/// - `t: &mut Transaction` -- Transaction associated to the operation.
/// - `ld: DartIdType` -- First dart ID.
///
/// The second dart ID is fetched using `I` and `ld`.
///
/// # Errors
///
/// This variant will abort the unsew operation and raise an error if:
/// - the transaction cannot be completed,
/// - one (or more) attribute split fails.
///
/// The returned error can be used in conjunction with transaction control to avoid any
/// modifications in case of failure at attribute level. The user can then choose to retry or
/// abort as he wishes using `Transaction::with_control`.
///
/// # Panics
///
/// The method may panic if:
/// - `I >= 4` or `I == 0`,
/// - `ld` is already `I`-free.
pub fn unsew_tx<const I: u8>(
&self,
t: &mut Transaction,
ld: DartIdType,
) -> TransactionClosureResult<(), SewError> {
// these assertions + match on a const are optimized away
assert!(I < 4);
assert_ne!(I, 0);
match I {
1 => self.one_unsew_tx(t, ld),
2 => self.two_unsew_tx(t, ld),
3 => self.three_unsew_tx(t, ld),
_ => unreachable!(),
}
}
#[allow(clippy::missing_errors_doc, clippy::missing_panics_doc)]
/// `I`-sew operator.
///
/// This variant is equivalent to [`sew`][Self::sew], but internally uses a transaction that
/// will be retried until validated.
pub fn sew<const I: u8>(&self, ld: DartIdType, rd: DartIdType) -> Result<(), SewError> {
// these assertions + match on a const are optimized away
assert!(I < 4);
assert_ne!(I, 0);
match I {
1 => atomically_with_err(|t| self.one_sew_tx(t, ld, rd)),
2 => atomically_with_err(|t| self.two_sew_tx(t, ld, rd)),
3 => atomically_with_err(|t| self.three_sew_tx(t, ld, rd)),
_ => unreachable!(),
}
}
#[allow(clippy::missing_errors_doc, clippy::missing_panics_doc)]
/// `I`-unsew operator.
///
/// This variant is equivalent to [`unsew`][Self::unsew], but internally uses a transaction that
/// will be retried until validated.
pub fn unsew<const I: u8>(&self, ld: DartIdType) -> Result<(), SewError> {
// these assertions + match on a const are optimized away
assert!(I < 4);
assert_ne!(I, 0);
match I {
1 => atomically_with_err(|t| self.one_unsew_tx(t, ld)),
2 => atomically_with_err(|t| self.two_unsew_tx(t, ld)),
3 => atomically_with_err(|t| self.three_unsew_tx(t, ld)),
_ => unreachable!(),
}
}
}