[libgee] Move virtual methods to Collection interface

[Maciej Marcin Piechotka <mpiechotka src gnome org>]

commit 82f7178f1bb706f763db89e28badbfd74fb1c826
Author: Maciej Piechotka <uzytkownik2 gmail com>
Date:   Sat Aug 11 23:22:13 2012 -0700

    Move virtual methods to Collection interface

 gee/abstractcollection.vala |  211 -------------------------------------------
 gee/arraylist.vala          |    2 +-
 gee/arrayqueue.vala         |    2 +-
 gee/collection.vala         |  180 +++++++++++++++++++++++++++++++++++--
 gee/concurrentlist.vala     |    2 +-
 gee/hashmap.vala            |   18 ++--
 gee/treemap.vala            |    6 +-
 gee/treeset.vala            |    2 +-
 tests/testcollection.vala   |    5 -
 9 files changed, 190 insertions(+), 238 deletions(-)
---
diff --git a/gee/abstractcollection.vala b/gee/abstractcollection.vala
index a31cf77..9db3160 100644
--- a/gee/abstractcollection.vala
+++ b/gee/abstractcollection.vala
@@ -31,7 +31,6 @@
  * @see AbstractMultiSet
  */
 public abstract class Gee.AbstractCollection<G> : Object, Traversable<G>, Iterable<G>, Collection<G> {
-
 	/**
 	 * { inheritDoc}
 	 */
@@ -40,13 +39,6 @@ public abstract class Gee.AbstractCollection<G> : Object, Traversable<G>, Iterab
 	/**
 	 * { inheritDoc}
 	 */
-	public virtual bool is_empty {
-		get { return size == 0; }
-	}
-
-	/**
-	 * { inheritDoc}
-	 */
 	public abstract bool read_only { get; }
 
 	/**
@@ -72,209 +64,6 @@ public abstract class Gee.AbstractCollection<G> : Object, Traversable<G>, Iterab
 	/**
 	 * { inheritDoc}
 	 */
-	public virtual G[] to_array () {
-		var t = typeof (G);
-		if (t == typeof (bool)) {
-			return (G[]) to_bool_array((Collection<bool>) this);
-		} else if (t == typeof (char)) {
-			return (G[]) to_char_array((Collection<char>) this);
-		} else if (t == typeof (uchar)) {
-			return (G[]) to_uchar_array((Collection<uchar>) this);
-		} else if (t == typeof (int)) {
-			return (G[]) to_int_array((Collection<int>) this);
-		} else if (t == typeof (uint)) {
-			return (G[]) to_uint_array((Collection<uint>) this);
-		} else if (t == typeof (int64)) {
-			return (G[]) to_int64_array((Collection<int64>) this);
-		} else if (t == typeof (uint64)) {
-			return (G[]) to_uint64_array((Collection<uint64>) this);
-		} else if (t == typeof (long)) {
-			return (G[]) to_long_array((Collection<long>) this);
-		} else if (t == typeof (ulong)) {
-			return (G[]) to_ulong_array((Collection<ulong>) this);
-		} else if (t == typeof (float)) {
-			return (G[]) to_float_array((Collection<float>) this);
-		} else if (t == typeof (double)) {
-			return (G[]) to_double_array((Collection<double>) this);
-		} else {
-			G[] array = new G[size];
-			int index = 0;
-			foreach (G element in this) {
-				array[index++] = element;
-			}
-			return array;
-		}
-	}
-
-	private static bool[] to_bool_array(Collection<bool> coll) {
-		bool[] array = new bool[coll.size];
-		int index = 0;
-		foreach (bool element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static char[] to_char_array(Collection<char> coll) {
-		char[] array = new char[coll.size];
-		int index = 0;
-		foreach (char element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static uchar[] to_uchar_array(Collection<uchar> coll) {
-		uchar[] array = new uchar[coll.size];
-		int index = 0;
-		foreach (uchar element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static int[] to_int_array(Collection<int> coll) {
-		int[] array = new int[coll.size];
-		int index = 0;
-		foreach (int element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static uint[] to_uint_array(Collection<uint> coll) {
-		uint[] array = new uint[coll.size];
-		int index = 0;
-		foreach (uint element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static int64[] to_int64_array(Collection<int64?> coll) {
-		int64[] array = new int64[coll.size];
-		int index = 0;
-		foreach (int64 element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static uint64[] to_uint64_array(Collection<uint64?> coll) {
-		uint64[] array = new uint64[coll.size];
-		int index = 0;
-		foreach (uint64 element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static long[] to_long_array(Collection<long> coll) {
-		long[] array = new long[coll.size];
-		int index = 0;
-		foreach (long element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	private static ulong[] to_ulong_array(Collection<ulong> coll) {
-		ulong[] array = new ulong[coll.size];
-		int index = 0;
-		foreach (ulong element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-#if VALA_0_16
-	private static float?[] to_float_array(Collection<float?> coll) {
-		float?[] array = new float?[coll.size];
-#else
-	private static float[] to_float_array(Collection<float?> coll) {
-		float[] array = new float[coll.size];
-#endif
-		int index = 0;
-		foreach (float element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-#if VALA_0_16
-	private static double?[] to_double_array(Collection<double?> coll) {
-		double?[] array = new double?[coll.size];
-#else
-	private static double[] to_double_array(Collection<double?> coll) {
-		double[] array = new double[coll.size];
-#endif
-		int index = 0;
-		foreach (double element in coll) {
-			array[index++] = element;
-		}
-		return array;
-	}
-
-	/**
-	 * { inheritDoc}
-	 */
-	public virtual bool add_all (Collection<G> collection) {
-		if (collection.is_empty) {
-			return false;
-		}
-
-		bool changed = false;
-		foreach (G item in collection) {
-			changed = changed | add (item);
-		}
-		return changed;
-	}
-
-	/**
-	 * { inheritDoc}
-	 */
-	public virtual bool contains_all (Collection<G> collection) {
-		if (collection.size > size) {
-			return false;
-		}
-
-		foreach (G item in collection) {
-			if (!contains (item)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	/**
-	 * { inheritDoc}
-	 */
-	public virtual bool remove_all (Collection<G> collection) {
-		bool changed = false;
-		foreach (G item in collection) {
-			changed = changed | remove (item);
-		}
-		return changed;
-	}
-
-	/**
-	 * { inheritDoc}
-	 */
-	public virtual bool retain_all (Collection<G> collection) {
-		bool changed = false;
-		G[] items = to_array ();
-		int size_of_items = size;
-		for (int index = 0; index < size_of_items; index++) {
-			if (!collection.contains (items[index])) {
-				changed = changed | remove (items[index]);
-			}
-		}
-		return changed;
-	}
-
-	/**
-	 * { inheritDoc}
-	 */
 	public Type element_type {
 		get { return typeof (G); }
 	}
diff --git a/gee/arraylist.vala b/gee/arraylist.vala
index 693130c..017eebe 100644
--- a/gee/arraylist.vala
+++ b/gee/arraylist.vala
@@ -224,7 +224,7 @@ public class Gee.ArrayList<G> : AbstractBidirList<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public override bool add_all (Collection<G> collection) {
+	public bool add_all (Collection<G> collection) {
 		if (collection.is_empty) {
 			return false;
 		}
diff --git a/gee/arrayqueue.vala b/gee/arrayqueue.vala
index ab1743b..ac10a15 100644
--- a/gee/arrayqueue.vala
+++ b/gee/arrayqueue.vala
@@ -55,7 +55,7 @@ public class Gee.ArrayQueue<G> : Gee.AbstractQueue<G>, Deque<G> {
 	 */
 	public override int size { get { return _length; } }
 
-	public override bool is_empty { get { return _length == 0; } }
+	public bool is_empty { get { return _length == 0; } }
 
 	/**
 	 * { inheritDoc}
diff --git a/gee/collection.vala b/gee/collection.vala
index 93238bd..e480450 100644
--- a/gee/collection.vala
+++ b/gee/collection.vala
@@ -33,7 +33,7 @@ public interface Gee.Collection<G> : Iterable<G> {
 	/**
 	 * Specifies whether this collection is empty.
 	 */
-	public abstract bool is_empty { get; }
+	public virtual bool is_empty { get { return size == 0; } }
 	
 	/**
 	 * Specifies whether this collection can change - i.e. wheather { link add},
@@ -84,7 +84,17 @@ public interface Gee.Collection<G> : Iterable<G> {
 	 *
 	 * @return     ``true`` if the collection has been changed, ``false`` otherwise
 	 */
-	public abstract bool add_all (Collection<G> collection);
+	public virtual bool add_all (Collection<G> collection) {
+		if (collection.is_empty) {
+			return false;
+		}
+
+		bool changed = false;
+		foreach (G item in collection) {
+			changed = changed | add (item);
+		}
+		return changed;
+	}
 
 	/**
 	 * Returns ``true`` it this collection contains all items as the input
@@ -95,7 +105,18 @@ public interface Gee.Collection<G> : Iterable<G> {
 	 *
 	 * @return     ``true`` if the collection has been changed, ``false`` otherwise
 	 */
-	public abstract bool contains_all (Collection<G> collection);
+	public virtual bool contains_all (Collection<G> collection) {
+		if (collection.size > size) {
+			return false;
+		}
+
+		foreach (G item in collection) {
+			if (!contains (item)) {
+				return false;
+			}
+		}
+		return true;
+	}
 
 	/**
 	 * Removes the subset of items in this collection corresponding to the
@@ -108,7 +129,13 @@ public interface Gee.Collection<G> : Iterable<G> {
 	 *
 	 * @return     ``true`` if the collection has been changed, ``false`` otherwise
 	 */
-	public abstract bool remove_all (Collection<G> collection);
+	public virtual bool remove_all (Collection<G> collection) {
+		bool changed = false;
+		foreach (G item in collection) {
+			changed = changed | remove (item);
+		}
+		return changed;
+	}
 
 	/**
 	 * Removes all items in this collection that are not contained in the input
@@ -120,14 +147,155 @@ public interface Gee.Collection<G> : Iterable<G> {
 	 *
 	 * @return     ``true`` if the collection has been changed, ``false`` otherwise
 	 */
-	public abstract bool retain_all (Collection<G> collection);
+	public virtual bool retain_all (Collection<G> collection) {
+		bool changed = false;
+		G[] items = to_array ();
+		int size_of_items = size;
+		for (int index = 0; index < size_of_items; index++) {
+			if (!collection.contains (items[index])) {
+				changed = changed | remove (items[index]);
+			}
+		}
+		return changed;
+	}
 
 	/**
 	 * Returns an array containing all of items from this collection.
 	 *
 	 * @return an array containing all of items from this collection
 	 */
-	public abstract G[] to_array();
+	public virtual G[] to_array () {
+		var t = typeof (G);
+		if (t == typeof (bool)) {
+			return (G[]) to_bool_array ((Collection<bool>) this);
+		} else if (t == typeof (char)) {
+			return (G[]) to_char_array ((Collection<char>) this);
+		} else if (t == typeof (uchar)) {
+			return (G[]) to_uchar_array ((Collection<uchar>) this);
+		} else if (t == typeof (int)) {
+			return (G[]) to_int_array ((Collection<int>) this);
+		} else if (t == typeof (uint)) {
+			return (G[]) to_uint_array ((Collection<uint>) this);
+		} else if (t == typeof (int64)) {
+			return (G[]) to_int64_array ((Collection<int64>) this);
+		} else if (t == typeof (uint64)) {
+			return (G[]) to_uint64_array ((Collection<uint64>) this);
+		} else if (t == typeof (long)) {
+			return (G[]) to_long_array ((Collection<long>) this);
+		} else if (t == typeof (ulong)) {
+			return (G[]) to_ulong_array ((Collection<ulong>) this);
+		} else if (t == typeof (float)) {
+			return (G[]) to_float_array ((Collection<float>) this);
+		} else if (t == typeof (double)) {
+			return (G[]) to_double_array ((Collection<double>) this);
+		} else {
+			G[] array = new G[size];
+			int index = 0;
+			foreach (G element in this) {
+				array[index++] = element;
+			}
+			return array;
+		}
+	}
+
+	private static bool[] to_bool_array (Collection<bool> coll) {
+		bool[] array = new bool[coll.size];
+		int index = 0;
+		foreach (bool element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static char[] to_char_array (Collection<char> coll) {
+		char[] array = new char[coll.size];
+		int index = 0;
+		foreach (char element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static uchar[] to_uchar_array (Collection<uchar> coll) {
+		uchar[] array = new uchar[coll.size];
+		int index = 0;
+		foreach (uchar element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static int[] to_int_array (Collection<int> coll) {
+		int[] array = new int[coll.size];
+		int index = 0;
+		foreach (int element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static uint[] to_uint_array (Collection<uint> coll) {
+		uint[] array = new uint[coll.size];
+		int index = 0;
+		foreach (uint element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static int64[] to_int64_array (Collection<int64?> coll) {
+		int64[] array = new int64[coll.size];
+		int index = 0;
+		foreach (int64 element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static uint64[] to_uint64_array (Collection<uint64?> coll) {
+		uint64[] array = new uint64[coll.size];
+		int index = 0;
+		foreach (uint64 element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static long[] to_long_array (Collection<long> coll) {
+		long[] array = new long[coll.size];
+		int index = 0;
+		foreach (long element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static ulong[] to_ulong_array (Collection<ulong> coll) {
+		ulong[] array = new ulong[coll.size];
+		int index = 0;
+		foreach (ulong element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static float?[] to_float_array (Collection<float?> coll) {
+		float?[] array = new float?[coll.size];
+		int index = 0;
+		foreach (float element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
+
+	private static double?[] to_double_array (Collection<double?> coll) {
+		double?[] array = new double?[coll.size];
+		int index = 0;
+		foreach (double element in coll) {
+			array[index++] = element;
+		}
+		return array;
+	}
 
 	/**
 	 * The read-only view of this collection.
diff --git a/gee/concurrentlist.vala b/gee/concurrentlist.vala
index 2d35997..5ef30c9 100644
--- a/gee/concurrentlist.vala
+++ b/gee/concurrentlist.vala
@@ -81,7 +81,7 @@ public class Gee.ConcurrentList<G> : AbstractList<G> {
 	/**
 	 * { inheritDoc}
 	 */
-	public override bool is_empty {
+	public bool is_empty {
 		get {
 			return !iterator ().next ();
 		}
diff --git a/gee/hashmap.vala b/gee/hashmap.vala
index 4096a90..eef1c18 100644
--- a/gee/hashmap.vala
+++ b/gee/hashmap.vala
@@ -363,15 +363,15 @@ public class Gee.HashMap<K,V> : Gee.AbstractMap<K,V> {
 			return _map.has_key (key);
 		}
 
-		public override bool add_all (Collection<K> collection) {
+		public bool add_all (Collection<K> collection) {
 			assert_not_reached ();
 		}
 
-		public override bool remove_all (Collection<K> collection) {
+		public bool remove_all (Collection<K> collection) {
 			assert_not_reached ();
 		}
 
-		public override bool retain_all (Collection<K> collection) {
+		public bool retain_all (Collection<K> collection) {
 			assert_not_reached ();
 		}
 
@@ -418,15 +418,15 @@ public class Gee.HashMap<K,V> : Gee.AbstractMap<K,V> {
 			return false;
 		}
 
-		public override bool add_all (Collection<V> collection) {
+		public bool add_all (Collection<V> collection) {
 			assert_not_reached ();
 		}
 
-		public override bool remove_all (Collection<V> collection) {
+		public bool remove_all (Collection<V> collection) {
 			assert_not_reached ();
 		}
 
-		public override bool retain_all (Collection<V> collection) {
+		public bool retain_all (Collection<V> collection) {
 			assert_not_reached ();
 		}
 	}
@@ -466,15 +466,15 @@ public class Gee.HashMap<K,V> : Gee.AbstractMap<K,V> {
 			return _map.has (entry.key, entry.value);
 		}
 
-		public override bool add_all (Collection<Map.Entry<K, V>> entries) {
+		public bool add_all (Collection<Map.Entry<K, V>> entries) {
 			assert_not_reached ();
 		}
 
-		public override bool remove_all (Collection<Map.Entry<K, V>> entries) {
+		public bool remove_all (Collection<Map.Entry<K, V>> entries) {
 			assert_not_reached ();
 		}
 
-		public override bool retain_all (Collection<Map.Entry<K, V>> entries) {
+		public bool retain_all (Collection<Map.Entry<K, V>> entries) {
 			assert_not_reached ();
 		}
 	}
diff --git a/gee/treemap.vala b/gee/treemap.vala
index bbe35c2..7e718cf 100644
--- a/gee/treemap.vala
+++ b/gee/treemap.vala
@@ -988,7 +988,7 @@ public class Gee.TreeMap<K,V> : Gee.AbstractBidirSortedMap<K,V> {
 			}
 		}
 
-		public override bool is_empty { get { return range.empty_submap (); } }
+		public bool is_empty { get { return range.empty_submap (); } }
 
 		public override bool add (K key) {
 			assert_not_reached ();
@@ -1147,7 +1147,7 @@ public class Gee.TreeMap<K,V> : Gee.AbstractBidirSortedMap<K,V> {
 			}
 		}
 
-		public override bool is_empty { get { return range.empty_submap (); } }
+		public bool is_empty { get { return range.empty_submap (); } }
 
 		public override bool add (V key) {
 			assert_not_reached ();
@@ -1290,7 +1290,7 @@ public class Gee.TreeMap<K,V> : Gee.AbstractBidirSortedMap<K,V> {
 			}
 		}
 
-		public override bool is_empty { get { return range.empty_submap (); } }
+		public bool is_empty { get { return range.empty_submap (); } }
 
 		public override bool add (Map.Entry<K,V> entry) {
 			assert_not_reached ();
diff --git a/gee/treeset.vala b/gee/treeset.vala
index a066290..771879e 100644
--- a/gee/treeset.vala
+++ b/gee/treeset.vala
@@ -928,7 +928,7 @@ public class Gee.TreeSet<G> : AbstractBidirSortedSet<G> {
 			get { return true; }
 		}
 
-		public override bool is_empty {
+		public bool is_empty {
 			get {
 				return range.empty_subset ();
 			}
diff --git a/tests/testcollection.vala b/tests/testcollection.vala
index 9450d44..0794369 100644
--- a/tests/testcollection.vala
+++ b/tests/testcollection.vala
@@ -744,11 +744,6 @@ public abstract class CollectionTests : Gee.TestCase {
 		assert (value.get_gtype () == test_collection.element_type);
 		value.unset ();
 
-		value = Value (typeof (bool));
-		test_collection.get_property ("is-empty", ref value);
-		assert (value.get_boolean () == test_collection.is_empty);
-		value.unset ();
-
 		value = Value (typeof (int));
 		test_collection.get_property ("size", ref value);
 		assert (value.get_int () == test_collection.size);