changes: TINF-175 TZPC-4722

[platform/upstream/libgee.git] / gee / functions.vala

diff --git a/gee/functions.vala b/gee/functions.vala
index 8b0c99e..0a72832 100644 (file)
--- a/gee/functions.vala
+++ b/gee/functions.vala
@@ -1,6 +1,6 @@
 /* functions.vala
  *
- * Copyright (C) 2009  Maciej Piechotka
+ * Copyright (C) 2009  Didier Villevalois, Maciej Piechotka
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,6 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  *
  * Author:
+ *     Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
  *     Maciej Piechotka <uzytkownik2@gmail.com>
  */
 
@@ -24,41 +25,128 @@ using GLib;
 
 namespace Gee {
 
-       public class Functions {
+       /**
+        * Helpers for equal, hash and compare functions.
+        *
+        * With those functions, you can retrieve the equal, hash and compare
+        * functions that best match your element, key or value types. Supported
+        * types are (non-boxed) primitive, string and ``Object`` types.
+        *
+        * A special care is taken for classes inheriting from the
+        * {@link Comparable} interface. For such types, an appropriate compare
+        * function is returned that calls {@link Comparable.compare_to}.
+        *
+        */
+       namespace Functions {
 
-               public static EqualFunc get_equal_func_for (Type t) {
+               /**
+                * Get a equality testing function for a given type.
+                *
+                * @param t the type which to get an equality testing function for.
+                *
+                * @return the equality testing function corresponding to the given type.
+                */
+               public static EqualDataFunc get_equal_func_for (Type t) {
                        if (t == typeof (string)) {
-                               return str_equal;
+                               return (a, b) => {
+                                       if (a == b)
+                                               return true;
+                                       else if (a == null || b == null)
+                                               return false;
+                                       else
+                                               return str_equal ((string) a, (string) b);
+                               };
+                       } else if (t.is_a (typeof (Hashable))) {
+                               return (a, b) => {
+                                       if (a == b)
+                                               return true;
+                                       else if (a == null || b == null)
+                                               return false;
+                                       else
+                                               return ((Hashable<Hashable>) a).equal_to ((Hashable) b);
+                               };
+                       } else if (t.is_a (typeof (Comparable))) {
+                               return (a, b) => {                                      
+                                       if (a == b)
+                                               return true;
+                                       else if (a == null || b == null)
+                                               return false;
+                                       else
+                                               return ((Comparable<Comparable>) a).compare_to ((Comparable) b) == 0;};
                        } else {
-                               return direct_equal;
+                               return (a, b) => {return direct_equal (a, b);};
                        }
                }
 
-               public static HashFunc get_hash_func_for (Type t) {
+               /**
+                * Get a hash function for a given type.
+                *
+                * @param t the type which to get the hash function for.
+                *
+                * @return the hash function corresponding to the given type.
+                */
+               public static HashDataFunc get_hash_func_for (Type t) {
                        if (t == typeof (string)) {
-                               return str_hash;
+                               return (a) => {
+                                       if (a == null)
+                                               return (uint)0xdeadbeef;
+                                       else
+                                               return str_hash ((string) a);
+                               };
+                       } else if (t.is_a (typeof (Hashable))) {
+                               return (a) => {
+                                       if (a == null)
+                                               return (uint)0xdeadbeef;
+                                       else
+                                               return ((Hashable) a).hash();
+                               };
                        } else {
-                               return direct_hash;
+                               return (a) => {return direct_hash (a);};
                        }
                }
 
-               public static CompareFunc get_compare_func_for (Type t) {
+               /**
+                * Get a comparator function for a given type.
+                *
+                * @param t the type which to get a comparator function for.
+                *
+                * @return the comparator function corresponding to the given type.
+                */
+               public static CompareDataFunc get_compare_func_for (Type t) {
                        if (t == typeof (string)) {
-                               return (CompareFunc) strcmp;
+                               return (a, b) => {
+                                       if (a == b)
+                                               return 0;
+                                       else if (a == null)
+                                               return -1;
+                                       else if (b == null)
+                                               return 1;
+                                       else
+                                               return strcmp((string) a, (string) b);
+                               };
+                       } else if (t.is_a (typeof (Comparable))) {
+                               return (a, b) => {
+                                       if (a == b)
+                                               return 0;
+                                       else if (a == null)
+                                               return -1;
+                                       else if (b == null)
+                                               return 1;
+                                       else
+                                               return ((Comparable<Comparable>) a).compare_to ((Comparable) b);
+                               };
                        } else {
-                               return direct_compare;
+                               return (_val1, _val2) => {
+                                       long val1 = (long)_val1, val2 = (long)_val2;
+                                       if (val1 > val2) {
+                                               return 1;
+                                       } else if (val1 == val2) {
+                                               return 0;
+                                       } else {
+                                               return -1;
+                                       }
+                               };
                        }
                }
        }
-
-       public static int direct_compare (void* _val1, void* _val2) {
-               long val1 = (long)_val1, val2 = (long)_val2;
-               if (val1 > val2) {
-                       return 1;
-               } else if (val1 == val2) {
-                       return 0;
-               } else {
-                       return -1;
-               }
-       }
 }