From 13d07ad0a623a8ceaaee4c5af20de1d1d8afddf7 Mon Sep 17 00:00:00 2001
From: Daniel Micay <danielmicay@gmail.com>
Date: Sun, 20 Jan 2013 13:46:06 -0500
Subject: [PATCH 1/2] add a Set trait and implement it for TreeSet
---
src/libcore/container.rs | 24 ++++++++++++++++++++++++
src/libcore/core.rc | 1 +
src/libstd/treemap.rs | 29 ++++++++++++++++-------------
3 files changed, 41 insertions(+), 13 deletions(-)
create mode 100644 src/libcore/container.rs
diff --git a/src/libcore/container.rs b/src/libcore/container.rs
new file mode 100644
index 0000000000000..619622ceb9511
--- /dev/null
+++ b/src/libcore/container.rs
@@ -0,0 +1,24 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Container traits
+
+pub trait Set<T> {
+ /// Return true if the set contains a value
+ pure fn contains(&self, value: &T) -> bool;
+
+ /// Add a value to the set. Return true if the value was not already
+ /// present in the set.
+ fn insert(&mut self, value: T) -> bool;
+
+ /// Remove a value from the set. Return true if the value was
+ /// present in the set.
+ fn remove(&mut self, value: &T) -> bool;
+}
diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index b800564b8e10c..24623f20c80c1 100644
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -122,6 +122,7 @@ pub mod to_bytes;
pub mod clone;
pub mod io;
pub mod hash;
+pub mod container;
/* Common data structures */
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index b5f60a66978e6..1b20b35bda1fb 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -14,6 +14,7 @@
#[forbid(deprecated_mode)];
+use core::container::Set;
use core::cmp::{Eq, Ord};
use core::option::{Option, Some, None};
use core::prelude::*;
@@ -197,6 +198,21 @@ impl <T: Eq Ord> TreeSet<T>: Eq {
pure fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map }
}
+impl <T: Ord> TreeSet<T>: Set<T> {
+ /// Return true if the set contains a value
+ pure fn contains(&self, value: &T) -> bool {
+ self.map.contains_key(value)
+ }
+
+ /// Add a value to the set. Return true if the value was not already
+ /// present in the set.
+ fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
+
+ /// Remove a value from the set. Return true if the value was
+ /// present in the set.
+ fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
+}
+
impl <T: Ord> TreeSet<T> {
/// Create an empty TreeSet
static pure fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
@@ -215,19 +231,6 @@ impl <T: Ord> TreeSet<T> {
self.map.each_key_reverse(f)
}
- /// Return true if the set contains a value
- pure fn contains(&self, value: &T) -> bool {
- self.map.contains_key(value)
- }
-
- /// Add a value to the set. Return true if the value was not
- /// already present in the set.
- fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
-
- /// Remove a value from the set. Return true if the value was
- /// present in the set.
- fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
-
/// Get a lazy iterator over the values in the set.
/// Requires that it be frozen (immutable).
pure fn iter(&self) -> TreeSetIterator/&self<T> {
From 5320e132d1f60a7787f8290b7d8c7e16fcf9ccae Mon Sep 17 00:00:00 2001
From: Daniel Micay <danielmicay@gmail.com>
Date: Sun, 20 Jan 2013 14:18:24 -0500
Subject: [PATCH 2/2] add a LinearSet type (implementing the Set trait)
---
src/libcore/send_map.rs | 47 +++++++++++++++++++++++++++++++++++++++--
1 file changed, 45 insertions(+), 2 deletions(-)
diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs
index 4cd3502bd6212..5c7b0643d3dec 100644
--- a/src/libcore/send_map.rs
+++ b/src/libcore/send_map.rs
@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
@@ -46,6 +46,8 @@ pub trait SendMap<K:Eq Hash, V: Copy> {
/// Open addressing with linear probing.
pub mod linear {
+ use iter::BaseIter;
+ use container::Set;
use cmp::Eq;
use cmp;
use hash::Hash;
@@ -442,7 +444,7 @@ pub mod linear {
}
}
- impl<K:Hash IterBytes Eq, V: Eq> LinearMap<K, V>: cmp::Eq {
+ impl<K:Hash IterBytes Eq, V: Eq> LinearMap<K, V>: Eq {
pure fn eq(&self, other: &LinearMap<K, V>) -> bool {
if self.len() != other.len() { return false; }
@@ -460,6 +462,47 @@ pub mod linear {
!self.eq(other)
}
}
+
+ pub struct LinearSet<T: Hash IterBytes Eq> {
+ priv map: LinearMap<T, ()>
+ }
+
+ impl <T: Hash IterBytes Eq> LinearSet<T>: BaseIter<T> {
+ /// Visit all values in order
+ pure fn each(&self, f: fn(&T) -> bool) { self.map.each_key(f) }
+ pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+ }
+
+ impl <T: Hash IterBytes Eq> LinearSet<T>: Eq {
+ pure fn eq(&self, other: &LinearSet<T>) -> bool { self.map == other.map }
+ pure fn ne(&self, other: &LinearSet<T>) -> bool { self.map != other.map }
+ }
+
+ impl <T: Hash IterBytes Eq> LinearSet<T>: Set<T> {
+ /// Return true if the set contains a value
+ pure fn contains(&self, value: &T) -> bool {
+ self.map.contains_key(value)
+ }
+
+ /// Add a value to the set. Return true if the value was not already
+ /// present in the set.
+ fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
+
+ /// Remove a value from the set. Return true if the value was
+ /// present in the set.
+ fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
+ }
+
+ impl <T: Hash IterBytes Eq> LinearSet<T> {
+ /// Create an empty LinearSet
+ static fn new() -> LinearSet<T> { LinearSet{map: LinearMap()} }
+
+ /// Return the number of elements in the set
+ pure fn len(&self) -> uint { self.map.len() }
+
+ /// Return true if the set contains no elements
+ pure fn is_empty(&self) -> bool { self.map.is_empty() }
+ }
}
#[test]