lisk77/comet
1
0
Fork 0
mirror of https://github.com/lisk77/comet.git synced 2025-10-25 06:18:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix: removed the garbage github copilot code out of flat_map and making iter_mut irrelevant

Browse source
This commit is contained in:
lisk77 2025-03-05 07:16:42 +01:00
parent f784fb2c02
commit 38b41985dc
5 changed files with 27 additions and 82 deletions
Download patch file Download diff file Expand all files Collapse all files

75
crates/comet_structs/src/flat_map.rs
View file

@ -1,83 +1,54 @@
#[derive(Clone)]
pub struct MapNode<K, V> {
key: K,
value: V
}
impl<K, V> MapNode<K,V> {
pub fn new(key: K, value: V) -> Self {
Self {
key,
value
}
}
pub fn key(&self) -> &K {
&self.key
}
pub fn value(&self) -> &V {
&self.value
}
}
#[derive(Clone)]
pub struct FlatMap<K: PartialEq, V> {
map: Vec<MapNode<K, V>>
map: Vec<(K,V)>
}
impl<K: PartialEq, V> FlatMap<K, V> {
impl<K: PartialEq + Clone, V: Clone> FlatMap<K, V> {
pub fn new() -> Self {
Self {
map: Vec::new()
}
}
pub fn keys(&self) -> Vec<&K> {
self.map.iter().map(|node| node.key()).collect::<Vec<&K>>()
pub fn keys(&self) -> Vec<K> {
self.map.iter().map(|node| node.0.clone()).collect::<Vec<K>>()
}
pub fn values(&self) -> Vec<&V> {
self.map.iter().map(|node| node.value()).collect::<Vec<&V>>()
}
pub fn keys_mut(&mut self) -> impl Iterator<Item = &mut K> {
self.map.iter_mut().map(|node| &mut node.key)
}
pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
self.map.iter_mut().map(|node| &mut node.value)
pub fn values(&self) -> Vec<V> {
self.map.iter().map(|node| node.1.clone()).collect::<Vec<V>>()
}
pub fn insert(&mut self, key: K, value: V) {
let node = MapNode::new(key, value);
self.map.push(node);
self.map.push((key,value));
}
pub fn remove(&mut self, key: &K) {
self.map.retain(|node| node.key() != key);
self.map.retain(|node| node.0 != *key);
}
pub fn get(&self, key: &K) -> Option<&V> {
self.map.iter()
.find(|node| node.key() == key)
.map(|node| node.value())
if let Some(node) = self.map.iter().find(|node| node.0 == *key) {
Some(&node.1)
}
else {
None
}
}
pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
self.map.iter_mut()
.find(|node| node.key() == key)
.map(|node| node.value_mut())
if let Some(node) = self.map.iter_mut().find(|node| node.0 == *key) {
Some(&mut node.1)
}
else {
None
}
}
pub fn contains(&self, key: &K) -> bool {
self.map.iter().any(|node| node.key() == key)
self.map.iter().any(|node| node.0 == *key)
}
}
// Add this method to MapNode to allow mutable access to value
impl<K, V> MapNode<K, V> {
fn value_mut(&mut self) -> &mut V {
&mut self.value
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (K, V)> {
self.map.iter_mut()
}
}