Move virtual methods to Collection interface

diff --git a/gee/abstractcollection.vala b/gee/abstractcollection.vala
index a31cf77..9db3160 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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);