···
use std::collections::VecDeque;
···
84
-
// Use Index trait instead
85
-
pub fn index(&self, n: usize) -> char {
86
-
debug_assert!(n < self.len());
89
-
Dna::Empty => unreachable!(),
91
-
Dna::TwoNode(node) => {
92
-
let (a, b) = &node.children;
96
-
b.index(n - a.len())
99
-
Dna::ThreeNode(node) => {
100
-
let (a, b, c) = &node.children;
103
-
} else if n < a.len() + b.len() {
104
-
b.index(n - a.len())
106
-
c.index(n - a.len() - b.len())
85
+
pub fn iter<'a>(&'a self) -> DnaIterator<'a> {
86
+
let mut stack = Vec::new();
88
+
DnaIterator { stack }
pub fn split(&self, n: usize) -> (DnaRef, DnaRef) {
debug_assert!(n <= self.len());
115
-
Dna::Empty => (Self::new(), Self::new()),
94
+
Dna::Empty => (DnaRef::new(), DnaRef::new()),
118
-
(Self::new(), Self::from_char(*c))
97
+
(DnaRef::new(), DnaRef::from_char(*c))
120
-
(Self::from_char(*c), Self::new())
99
+
(DnaRef::from_char(*c), DnaRef::new())
···
(a.clone(), b.clone() + c.clone())
} else if n - a.len() < b.len() {
let (x, y) = b.split(n - a.len());
144
-
(a.clone() + x, y + c.clone())
123
+
(a.clone() + x, y + c.clone())
} else if n == a.len() + b.len() {
146
-
(a.clone() + b.clone(), c.clone())
125
+
(a.clone() + b.clone(), c.clone())
let (x, y) = c.split(n - a.len() - b.len());
149
-
(a.clone() + b.clone() + x, y)
128
+
(a.clone() + b.clone() + x, y)
155
-
pub fn iter<'a>(&'a self) -> DnaIterator<'a> {
156
-
let mut stack = Vec::new();
158
-
DnaIterator { stack }
···
271
-
fn add_helper(lhs: DnaRef, rhs: DnaRef) -> AddState {
272
-
if lhs.depth() == rhs.depth() {
273
-
AddState::Two(lhs, rhs)
274
-
} else if lhs.depth() < rhs.depth() {
276
-
Dna::Empty => unreachable!(),
277
-
Dna::Leaf(_) => unreachable!(),
278
-
Dna::TwoNode(node) => {
279
-
let (a, b) = &node.children;
280
-
match add_helper(lhs, a.clone()) {
281
-
AddState::One(x) => {
282
-
AddState::One(DnaRef::from_two_children(x, b.clone()))
284
-
AddState::Two(x, y) => {
285
-
AddState::One(DnaRef::from_three_children(x, y, b.clone()))
244
+
fn add_helper(lhs: DnaRef, rhs: DnaRef) -> AddState {
245
+
if lhs.depth() == rhs.depth() {
246
+
AddState::Two(lhs, rhs)
247
+
} else if lhs.depth() < rhs.depth() {
249
+
Dna::Empty => unreachable!(),
250
+
Dna::Leaf(_) => unreachable!(),
251
+
Dna::TwoNode(node) => {
252
+
let (a, b) = &node.children;
253
+
match add_helper(lhs, a.clone()) {
254
+
AddState::One(x) => AddState::One(DnaRef::from_two_children(x, b.clone())),
255
+
AddState::Two(x, y) => {
256
+
AddState::One(DnaRef::from_three_children(x, y, b.clone()))
289
-
Dna::ThreeNode(node) => {
290
-
let (a, b, c) = &node.children;
291
-
match add_helper(lhs, a.clone()) {
292
-
AddState::One(x) => {
293
-
AddState::One(DnaRef::from_three_children(x, b.clone(), c.clone()))
295
-
AddState::Two(x, y) => AddState::Two(
296
-
DnaRef::from_two_children(x, y),
297
-
DnaRef::from_two_children(b.clone(), c.clone()),
260
+
Dna::ThreeNode(node) => {
261
+
let (a, b, c) = &node.children;
262
+
match add_helper(lhs, a.clone()) {
263
+
AddState::One(x) => {
264
+
AddState::One(DnaRef::from_three_children(x, b.clone(), c.clone()))
266
+
AddState::Two(x, y) => AddState::Two(
267
+
DnaRef::from_two_children(x, y),
268
+
DnaRef::from_two_children(b.clone(), c.clone()),
304
-
Dna::Empty => unreachable!(),
305
-
Dna::Leaf(_) => unreachable!(),
306
-
Dna::TwoNode(node) => {
307
-
let (a, b) = &node.children;
308
-
match add_helper(b.clone(), rhs) {
309
-
AddState::One(x) => {
310
-
AddState::One(DnaRef::from_two_children(a.clone(), x))
312
-
AddState::Two(x, y) => {
313
-
AddState::One(DnaRef::from_three_children(a.clone(), x, y))
275
+
Dna::Empty => unreachable!(),
276
+
Dna::Leaf(_) => unreachable!(),
277
+
Dna::TwoNode(node) => {
278
+
let (a, b) = &node.children;
279
+
match add_helper(b.clone(), rhs) {
280
+
AddState::One(x) => AddState::One(DnaRef::from_two_children(a.clone(), x)),
281
+
AddState::Two(x, y) => {
282
+
AddState::One(DnaRef::from_three_children(a.clone(), x, y))
317
-
Dna::ThreeNode(node) => {
318
-
let (a, b, c) = &node.children;
319
-
match add_helper(c.clone(), rhs) {
320
-
AddState::One(x) => {
321
-
AddState::One(DnaRef::from_three_children(a.clone(), b.clone(), x))
323
-
AddState::Two(x, y) => AddState::Two(
324
-
DnaRef::from_two_children(a.clone(), b.clone()),
325
-
DnaRef::from_two_children(x, y),
286
+
Dna::ThreeNode(node) => {
287
+
let (a, b, c) = &node.children;
288
+
match add_helper(c.clone(), rhs) {
289
+
AddState::One(x) => {
290
+
AddState::One(DnaRef::from_three_children(a.clone(), b.clone(), x))
292
+
AddState::Two(x, y) => AddState::Two(
293
+
DnaRef::from_two_children(a.clone(), b.clone()),
294
+
DnaRef::from_two_children(x, y),
334
-
type Output = Self;
303
+
type Output = Self;
fn add(self, other: Self) -> Self {
match add_helper(self, other) {
···
313
+
impl Index<usize> for DnaRef {
314
+
type Output = char;
316
+
fn index(&self, n: usize) -> &Self::Output {
317
+
debug_assert!(n < self.len());
320
+
Dna::Empty => unreachable!(),
322
+
Dna::TwoNode(node) => {
323
+
let (a, b) = &node.children;
327
+
b.index(n - a.len())
330
+
Dna::ThreeNode(node) => {
331
+
let (a, b, c) = &node.children;
334
+
} else if n < a.len() + b.len() {
335
+
b.index(n - a.len())
337
+
c.index(n - a.len() - b.len())
···
let dna: DnaRef = DnaRef::from_string(s);
for (i, c) in s.chars().enumerate() {
365
-
assert_eq!(dna.index(i), c);
365
+
assert_eq!(dna[i], c);
···
let lhs = DnaRef::from_string("ABCD");
let rhs = DnaRef::from_string("WXYZ");
374
-
(lhs + rhs).iter().collect::<String>(),
373
+
assert_eq!((lhs + rhs).iter().collect::<String>(), "ABCDWXYZ");
drubery.com