pli 0.1.10

pli
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

use std::ops::{Index, IndexMut};

pub struct Pli<'a> {
  txt_li: &'a mut [String],
  pos_li: Vec<usize>,
}

impl<'a> Pli<'a> {
  pub fn len(&self) -> usize {
    self.pos_li.len()
  }

  pub fn is_empty(&self) -> bool {
    self.pos_li.is_empty()
  }

  pub fn new(txt_li: &'a mut [String], pos_li: Vec<usize>) -> Self {
    Pli { txt_li, pos_li }
  }

  pub fn iter(&'a self) -> impl Iterator<Item = &'a str> {
    self.pos_li.iter().map(move |&pos| &self.txt_li[pos][..])
  }

  pub fn iter_mut(&'a mut self) -> impl Iterator<Item = Pos<'a>> {
    let txt_li_ptr = self.txt_li as *mut [String];
    let pos_li = self.pos_li.clone();
    pos_li.into_iter().map(move |pos| Pos {
      txt_li: unsafe { &mut *txt_li_ptr },
      pos,
    })
  }
}

impl<'a> Index<usize> for Pli<'a> {
  type Output = String;

  fn index(&self, index: usize) -> &Self::Output {
    &self.txt_li[self.pos_li[index]]
  }
}

impl<'a> IndexMut<usize> for Pli<'a> {
  fn index_mut(&mut self, index: usize) -> &mut Self::Output {
    &mut self.txt_li[self.pos_li[index]]
  }
}

use std::ops::{Deref, DerefMut};

pub struct Pos<'a> {
  txt_li: &'a mut [String],
  pos: usize,
}

impl<'a> Deref for Pos<'a> {
  type Target = String;

  fn deref(&self) -> &Self::Target {
    &self.txt_li[self.pos]
  }
}

impl<'a> DerefMut for Pos<'a> {
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut self.txt_li[self.pos]
  }
}

impl<'a> Pos<'a> {
  pub fn as_str(&self) -> &str {
    &self.txt_li[self.pos]
  }
}

impl<'a> AsRef<str> for Pos<'a> {
  fn as_ref(&self) -> &str {
    self.as_str()
  }
}