Skip to main content

f1r3fly_models/rust/
sorted_par_map.rs

1// See models/src/main/scala/coop/rchain/models/SortedParMap.scala
2
3use std::collections::HashMap;
4
5use crate::rhoapi::Par;
6
7use super::rholang::sorter::{
8    ordering::Ordering, par_sort_matcher::ParSortMatcher, sortable::Sortable,
9};
10
11#[derive(Clone, Debug)]
12pub struct SortedParMap {
13    pub ps: HashMap<Par, Par>,
14    // TODO: Merge `sortedList` and `sortedMap` into one VectorMap once available - OLD
15    pub sorted_list: Vec<(Par, Par)>,
16    sorted_map: HashMap<Par, Par>,
17}
18
19impl SortedParMap {
20    pub fn create_from_map(map: HashMap<Par, Par>) -> Self {
21        let sorted_list = Ordering::sort_map(&map);
22        let sorted_map = sorted_list.clone().into_iter().collect();
23
24        SortedParMap {
25            ps: map,
26            sorted_list,
27            sorted_map,
28        }
29    }
30
31    pub fn create_from_vec(vec: Vec<(Par, Par)>) -> Self {
32        let map: HashMap<Par, Par> = vec.into_iter().collect();
33        SortedParMap::create_from_map(map)
34    }
35
36    pub fn create_from_empty() -> Self {
37        SortedParMap::create_from_map(HashMap::new())
38    }
39
40    // alias for '+'
41    pub fn insert(&mut self, kv: (Par, Par)) -> SortedParMap {
42        self.sorted_map.insert(kv.0, kv.1);
43        Self::create_from_map(self.sorted_map.clone())
44    }
45
46    // alias for '++'
47    pub fn extend(&mut self, kvs: Vec<(Par, Par)>) -> SortedParMap {
48        for kv in kvs {
49            self.insert(kv);
50        }
51        Self::create_from_map(self.sorted_map.clone())
52    }
53
54    // alias for '-'
55    pub fn remove(&mut self, key: Par) -> SortedParMap {
56        self.sorted_map.remove(&Self::sort(&key));
57        Self::create_from_map(self.sorted_map.clone())
58    }
59
60    // alias for '--'
61    pub fn remove_multiple(&mut self, keys: Vec<Par>) -> SortedParMap {
62        for key in keys {
63            self.sorted_map.remove(&Self::sort(&key));
64        }
65        Self::create_from_map(self.sorted_map.clone())
66    }
67
68    pub fn apply(&self, key: Par) -> Option<Par> {
69        self.sorted_map.get(&Self::sort(&key)).cloned()
70    }
71
72    pub fn contains(&self, par: Par) -> bool {
73        self.sorted_map.contains_key(&SortedParMap::sort(&par))
74    }
75
76    pub fn get(&self, key: Par) -> Option<Par> {
77        self.sorted_map.get(&SortedParMap::sort(&key)).cloned()
78    }
79
80    pub fn get_or_else(&self, key: Par, default: Par) -> Par {
81        // println!("\nsorted_map in get_or_else: {:?}", self.sorted_map);
82        // println!("\nkey in get_or_else: {:?}", key);
83        match self.sorted_map.get(&SortedParMap::sort(&key)) {
84            Some(value) => value.clone(),
85            None => default,
86        }
87    }
88
89    pub fn keys(&self) -> Vec<Par> {
90        self.sorted_list
91            .clone()
92            .into_iter()
93            .map(|kv| kv.0)
94            .collect()
95    }
96
97    pub fn values(&self) -> Vec<Par> {
98        self.sorted_list
99            .clone()
100            .into_iter()
101            .map(|kv| kv.1)
102            .collect()
103    }
104
105    pub fn equals(&self, that: SortedParMap) -> bool {
106        self.sorted_list == that.sorted_list
107    }
108
109    pub fn length(&self) -> usize {
110        self.sorted_list.len()
111    }
112
113    pub fn is_empty(&self) -> bool {
114        self.ps.is_empty() && self.sorted_list.is_empty() && self.sorted_map.is_empty()
115    }
116
117    fn sort(par: &Par) -> Par {
118        ParSortMatcher::sort_match(&par).term.clone()
119    }
120}
121
122impl IntoIterator for SortedParMap {
123    type Item = (Par, Par);
124    type IntoIter = std::vec::IntoIter<Self::Item>;
125
126    fn into_iter(self) -> Self::IntoIter {
127        self.sorted_list.into_iter()
128    }
129}
130
131impl PartialEq for SortedParMap {
132    fn eq(&self, other: &Self) -> bool {
133        self.sorted_list == other.sorted_list
134    }
135}