GNOME.org
 

[libgee] Add read_only_view to SortedSet

commit 63c5d1c853da8817c8154cd3b2c9f9543db521ad
Author: Maciej Piechotka <uzytkownik2 gmail com>
Date:   Wed Oct 7 23:59:34 2009 +0100

    Add read_only_view to SortedSet

 gee/Makefile.am            |    2 +
 gee/abstractsortedset.vala |  103 ++++++++++++++++++++++++++++++
 gee/readonlysortedset.vala |  152 ++++++++++++++++++++++++++++++++++++++++++++
 gee/sortedset.vala         |   15 ++++
 gee/treemap.vala           |   16 +++++
 gee/treeset.vala           |   50 +++++++-------
 6 files changed, 313 insertions(+), 25 deletions(-)
---
diff --git a/gee/Makefile.am b/gee/Makefile.am
index 30f6c99..bef9dc4 100644
--- a/gee/Makefile.am
+++ b/gee/Makefile.am
@@ -12,6 +12,7 @@ libgee_la_SOURCES = \
 	abstractmultiset.vala \
 	abstractqueue.vala \
 	abstractset.vala \
+	abstractsortedset.vala \
 	arraylist.vala \
 	bidiriterator.vala \
 	bidirmapiterator.vala \
@@ -39,6 +40,7 @@ libgee_la_SOURCES = \
 	readonlylist.vala \
 	readonlymap.vala \
 	readonlyset.vala \
+	readonlysortedset.vala \
 	set.vala \
 	sortedmap.vala \
 	sortedset.vala \
diff --git a/gee/abstractsortedset.vala b/gee/abstractsortedset.vala
new file mode 100644
index 0000000..7663d72
--- /dev/null
+++ b/gee/abstractsortedset.vala
@@ -0,0 +1,103 @@
+/* abstractsortedset.vala
+ *
+ * Copyright (C) 2009-2011  Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ * 	Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Skeletal implementation of the { link SortedSet} interface.
+ *
+ * Contains common code shared by all set implementations.
+ *
+ * @see TreeSet
+ */
+public abstract class Gee.AbstractSortedSet<G> : Gee.AbstractSet<G>, SortedSet<G> {
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract G first ();
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract G last ();
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract BidirIterator<G> bidir_iterator ();
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract BidirIterator<G>? iterator_at (G element);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract G? lower (G element);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract G? higher (G element);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract G? floor (G element);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract G? ceil (G element);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract SortedSet<G> head_set (G before);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract SortedSet<G> tail_set (G after);
+
+	/**
+	 * { inheritDoc}
+	 */
+	public abstract SortedSet<G> sub_set (G from, G to);
+	
+	private weak SortedSet<G> _read_only_view;
+	
+	/**
+	 * { inheritDoc}
+	 */
+	public virtual new SortedSet<G> read_only_view {
+		owned get {
+			SortedSet<G> instance = _read_only_view;
+			if (_read_only_view == null) {
+				instance = new ReadOnlySortedSet<G> (this);
+				_read_only_view = instance;
+				instance.add_weak_pointer ((void**) (&_read_only_view));
+			}
+			return instance;
+		}
+	}
+}
+
diff --git a/gee/readonlysortedset.vala b/gee/readonlysortedset.vala
new file mode 100644
index 0000000..54d1786
--- /dev/null
+++ b/gee/readonlysortedset.vala
@@ -0,0 +1,152 @@
+/* readonlysortedset.vala
+ *
+ * Copyright (C) 2009  Didier Villevalois, Maciej Piechotka
+ * Copyright (C) 2011  Maciej Piechotka
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ * 	Maciej Piechotka <uzytkownik2 gmail com>
+ */
+
+/**
+ * Read-only view for { link SortedSet} collections.
+ *
+ * This class decorates any class which implements the { link SortedSet} interface
+ * by making it read only. Any method which normally modify data will throw an
+ * error.
+ *
+ * @see SortedSet
+ */
+internal class Gee.ReadOnlySortedSet<G> : ReadOnlySet<G>, SortedSet<G> {
+	/**
+	 * Constructs a read-only set that mirrors the content of the specified set.
+	 *
+	 * @param set the set to decorate.
+	 */
+	public ReadOnlySortedSet (SortedSet<G> set) {
+		base (set);
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public G first () {
+		return (_collection as SortedSet<G>).first ();
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public G last () {
+		return (_collection as SortedSet<G>).last ();
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public Gee.BidirIterator<G> bidir_iterator () {
+		return new BidirIterator<G> ((_collection as SortedSet<G>).bidir_iterator ());
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public Gee.BidirIterator<G>? iterator_at (G element) {
+		var iter = (_collection as SortedSet<G>).iterator_at (element);
+		return (iter != null) ? new BidirIterator<G> (iter) : null;
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public G? lower (G element) {
+		return (_collection as SortedSet<G>).lower (element);
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public G? higher (G element) {
+		return (_collection as SortedSet<G>).higher (element);
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public G? floor (G element) {
+		return (_collection as SortedSet<G>).floor (element);
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public G? ceil (G element) {
+		return (_collection as SortedSet<G>).ceil (element);
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public SortedSet<G> head_set (G before) {
+		return (_collection as SortedSet<G>).head_set (before).read_only_view;
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public SortedSet<G> tail_set (G after) {
+		return(_collection as SortedSet<G>).tail_set (after).read_only_view;
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public SortedSet<G> sub_set (G from, G to) {
+		return (_collection as SortedSet<G>).sub_set (from, to).read_only_view;
+	}
+
+	/**
+	 * { inheritDoc}
+	 */
+	public new SortedSet<G> read_only_view {
+		owned get {
+			return this;
+		}
+	}
+
+	protected class BidirIterator<G> : Gee.ReadOnlyCollection.Iterator<G>, Gee.BidirIterator<G> {
+		public BidirIterator (Gee.BidirIterator<G> iterator) {
+			base (iterator);
+		}
+
+		public bool first () {
+			return (_iter as Gee.BidirIterator<G>).first ();
+		}
+
+		public bool previous () {
+			return (_iter as Gee.BidirIterator<G>).previous ();
+		}
+
+		public bool has_previous () {
+			return (_iter as Gee.BidirIterator<G>).has_previous ();
+		}
+
+		public bool last () {
+			return (_iter as Gee.BidirIterator<G>).last ();
+		}
+	}
+}
+
diff --git a/gee/sortedset.vala b/gee/sortedset.vala
index a8058c3..318c748 100644
--- a/gee/sortedset.vala
+++ b/gee/sortedset.vala
@@ -1,6 +1,7 @@
 /* sortedset.vala
  *
  * Copyright (C) 2009  Didier Villevalois, Maciej Piechotka
+ * Copyright (C) 2011  Maciej Piechotka
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -126,4 +127,18 @@ public interface Gee.SortedSet<G> : Gee.Set<G> {
 	 * @return     the corresponding sub-set of this sorted set
 	 */
 	public abstract SortedSet<G> sub_set (G from, G to);
+
+	/**
+	 * The read-only view of this set.
+	 */
+	public abstract new SortedSet<G> read_only_view { owned get; }
+
+	/**
+	 * Returns an immutable empty sorted set.
+	 *
+	 * @return an immutable empty sorted set
+	 */
+	public static SortedSet<G> empty<G> () {
+		return new TreeSet<G> ().read_only_view;
+	}
 }
diff --git a/gee/treemap.vala b/gee/treemap.vala
index d708202..e0828d0 100644
--- a/gee/treemap.vala
+++ b/gee/treemap.vala
@@ -961,6 +961,10 @@ public class Gee.TreeMap<K,V> : Gee.AbstractMap<K,V>, SortedMap<K,V> {
 		public K? ceil (K item) {
 			return _map.lift_null_key (_map.find_ceil (item));
 		}
+
+		public new SortedSet<K> read_only_view {
+			owned get { return this; }
+		}
 	}
 
 	private class SubKeySet<K,V> : AbstractSet<K>, SortedSet<K> {
@@ -1078,6 +1082,10 @@ public class Gee.TreeMap<K,V> : Gee.AbstractMap<K,V>, SortedMap<K,V> {
 			var h = map.lift_null_key (map.find_ceil (key));
 			return h != null && range.in_range (h) ? h : null;
 		}
+
+		public new SortedSet<K> read_only_view {
+			owned get { return this; }
+		}
 	}
 
 	private class ValueCollection<K,V> : AbstractCollection<V> {
@@ -1263,6 +1271,10 @@ public class Gee.TreeMap<K,V> : Gee.AbstractMap<K,V>, SortedMap<K,V> {
 			weak Node<K,V>? l = _map.find_ceil (item.key);
 			return l != null ? Entry.entry_for<K,V> (l) : null;
 		}
+
+		public new SortedSet<Map.Entry<K, V>> read_only_view {
+			owned get { return this; }
+		}
 	}
 
 	private class SubEntrySet<K,V> : AbstractSet<Map.Entry<K,V>>, SortedSet<Map.Entry<K,V>> {
@@ -1380,6 +1392,10 @@ public class Gee.TreeMap<K,V> : Gee.AbstractMap<K,V>, SortedMap<K,V> {
 			weak Node<K,V>? h = map.find_ceil (entry.key);
 			return h != null && range.in_range (h.key) ? Entry.entry_for<K,V> (h) : null;
 		}
+
+		public new SortedSet<Map.Entry<K, V>> read_only_view {
+			owned get { return this; }
+		}
 	}
 
 	private class NodeIterator<K, V> : Object {
diff --git a/gee/treeset.vala b/gee/treeset.vala
index 6e2af21..e9dbfef 100644
--- a/gee/treeset.vala
+++ b/gee/treeset.vala
@@ -1,6 +1,6 @@
 /* treeset.vala
  *
- * Copyright (C) 2009-2010  Maciej Piechotka
+ * Copyright (C) 2009-2011  Maciej Piechotka
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -32,7 +32,7 @@ using GLib;
  *
  * @see HashSet
  */
-public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
+public class Gee.TreeSet<G> : AbstractSortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
@@ -350,7 +350,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public BidirIterator<G> bidir_iterator () {
+	public override BidirIterator<G> bidir_iterator () {
 		return new Iterator<G> (this);
 	}
 
@@ -361,7 +361,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public G first () {
+	public override G first () {
 		assert (_first != null);
 		return _first.key;
 	}
@@ -369,7 +369,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public G last () {
+	public override G last () {
 		assert (_last != null);
 		return _last.key;
 	}
@@ -377,21 +377,21 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public SortedSet<G> head_set (G before) {
+	public override SortedSet<G> head_set (G before) {
 		return new SubSet<G>.head (this, before);
 	}
 
 	/**
 	 * { inheritDoc}
 	 */
-	public SortedSet<G> tail_set (G after) {
+	public override SortedSet<G> tail_set (G after) {
 		return new SubSet<G>.tail (this, after);
 	}
 
 	/**
 	 * { inheritDoc}
 	 */
-	public SortedSet<G> sub_set (G after, G before) {
+	public override SortedSet<G> sub_set (G after, G before) {
 		return new SubSet<G> (this, after, before);
 	}
 
@@ -413,7 +413,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public BidirIterator<G>? iterator_at (G item) {
+	public override BidirIterator<G>? iterator_at (G item) {
 		weak Node<G>? node = find_node (item);
 		return node != null ? new Iterator<G>.pointing (this, node) : null;
 	}
@@ -468,28 +468,28 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public G? lower (G item) {
+	public override G? lower (G item) {
 		return lift_null_get (find_lower (item));
 	}
 
 	/**
 	 * { inheritDoc}
 	 */
-	public G? higher (G item) {
+	public override G? higher (G item) {
 		return lift_null_get (find_higher (item));
 	}
 
 	/**
 	 * { inheritDoc}
 	 */
-	public G? floor (G item) {
+	public override G? floor (G item) {
 		return lift_null_get (find_floor (item));
 	}
 
 	/**
 	 * { inheritDoc}
 	 */
-	public G? ceil (G item) {
+	public override G? ceil (G item) {
 		return lift_null_get (find_ceil (item));
 	}
 
@@ -888,7 +888,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 		BOUNDED
 	}
 
-	private class SubSet<G> : AbstractSet<G>, SortedSet<G> {
+	private class SubSet<G> : AbstractSortedSet<G> {
 		public SubSet (TreeSet<G> set, G after, G before) {
 			this.set = set;
 			this.range = new Range<G> (set, after, before);
@@ -952,35 +952,35 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 			return new SubIterator<G> (set, range);
 		}
 
-		public BidirIterator<G> bidir_iterator () {
+		public override BidirIterator<G> bidir_iterator () {
 			return new SubIterator<G> (set, range);
 		}
 
-		public G first () {
+		public override G first () {
 			weak Node<G>? _first = range.first ();
 			assert (_first != null);
 			return _first.key;
 		}
 
-		public G last () {
+		public override G last () {
 			weak Node<G>? _last = range.last ();
 			assert (_last != null);
 			return _last.key;
 		}
 
-		public SortedSet<G> head_set (G before) {
+		public override SortedSet<G> head_set (G before) {
 			return new SubSet<G>.from_range (set, range.cut_tail (before));
 		}
 
-		public SortedSet<G> tail_set (G after) {
+		public override SortedSet<G> tail_set (G after) {
 			return new SubSet<G>.from_range (set, range.cut_head (after));
 		}
 
-		public SortedSet<G> sub_set (G after, G before) {
+		public override SortedSet<G> sub_set (G after, G before) {
 			return new SubSet<G>.from_range (set, range.cut (after, before));
 		}
 
-		public BidirIterator<G>? iterator_at (G item) {
+		public override BidirIterator<G>? iterator_at (G item) {
 			if (!range.in_range (item))
 				return null;
 			weak Node<G>? n = set.find_node (item);
@@ -989,7 +989,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 			return new SubIterator<G>.pointing (set, range, n);
 		}
 
-		public G? lower (G item) {
+		public override G? lower (G item) {
 			var res = range.compare_range (item);
 			if (res > 0)
 				return last ();
@@ -997,7 +997,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 			return l != null && range.in_range (l) ? l : null;
 		}
 
-		public G? higher (G item) {
+		public override G? higher (G item) {
 			var res = range.compare_range (item);
 			if (res < 0)
 				return first ();
@@ -1005,7 +1005,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 			return h != null && range.in_range (h) ? h : null;
 		}
 
-		public G? floor (G item) {
+		public override G? floor (G item) {
 			var res = range.compare_range (item);
 			if (res > 0)
 				return last ();
@@ -1013,7 +1013,7 @@ public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
 			return l != null && range.in_range (l) ? l : null;
 		}
 
-		public G? ceil (G item) {
+		public override G? ceil (G item) {
 			var res = range.compare_range (item);
 			if (res < 0)
 				return first ();
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]