felipealmeida pushed a commit to branch master.
http://git.enlightenment.org/core/efl.git/commit/?id=74e79b5ae27efa7ed8f4baa1a9c1ae91cd52d178
commit 74e79b5ae27efa7ed8f4baa1a9c1ae91cd52d178
Author: Lauro Moura <lauromo...@expertisesolutions.com.br>
Date: Mon Sep 30 23:08:44 2019 -0300
csharp: Allow improved cbs in eina comparators
Summary:
Instead of receiving a callback that compares two intptrs (which is
still used internally), expose a more C#-friendly delegate which is
wrapped into the native one.
Test Plan: run test suite
Reviewers: felipealmeida, segfaultxavi, brunobelo
Reviewed By: felipealmeida
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10253
---
src/bindings/mono/eina_mono/eina_common.cs | 2 +-
.../mono/eina_mono/eina_container_common.cs | 4 +-
src/bindings/mono/eina_mono/eina_list.cs | 23 ++++++++---
src/bindings/mono/eo_mono/workaround.cs | 1 -
src/tests/efl_mono/Eina.cs | 44 ++++++++++++++++++++++
5 files changed, 64 insertions(+), 10 deletions(-)
diff --git a/src/bindings/mono/eina_mono/eina_common.cs
b/src/bindings/mono/eina_mono/eina_common.cs
index 029b08e820..7d97a9142e 100644
--- a/src/bindings/mono/eina_mono/eina_common.cs
+++ b/src/bindings/mono/eina_mono/eina_common.cs
@@ -10,7 +10,7 @@ namespace Eina
namespace Callbacks
{
-public delegate int EinaCompareCb(IntPtr data1, IntPtr data2);
+internal delegate int EinaCompareCb(IntPtr data1, IntPtr data2);
public delegate void EinaFreeCb(IntPtr data);
}
diff --git a/src/bindings/mono/eina_mono/eina_container_common.cs
b/src/bindings/mono/eina_mono/eina_container_common.cs
index 603b0694ec..9798aff923 100644
--- a/src/bindings/mono/eina_mono/eina_container_common.cs
+++ b/src/bindings/mono/eina_mono/eina_container_common.cs
@@ -494,7 +494,7 @@ public class EflObjectElementTraits<T> :
IBaseElementTraits<T>
public abstract class PrimitiveElementTraits<T>
{
- private Eina_Compare_Cb dlgt = null;
+ private Eina.Callbacks.EinaCompareCb dlgt = null;
public IntPtr ManagedToNativeAlloc(T man)
{
@@ -571,7 +571,7 @@ public abstract class PrimitiveElementTraits<T>
{
if (dlgt == null)
{
- dlgt = new Eina_Compare_Cb(PrimitiveCompareCb);
+ dlgt = new Eina.Callbacks.EinaCompareCb(PrimitiveCompareCb);
}
return Marshal.GetFunctionPointerForDelegate(dlgt);
diff --git a/src/bindings/mono/eina_mono/eina_list.cs
b/src/bindings/mono/eina_mono/eina_list.cs
index 9fe5e90d77..c65801ce13 100644
--- a/src/bindings/mono/eina_mono/eina_list.cs
+++ b/src/bindings/mono/eina_mono/eina_list.cs
@@ -110,6 +110,10 @@ public class List<T> : IEnumerable<T>, IDisposable
public bool Own {get;set;}
public bool OwnContent {get;set;}
+ /// <summary>Delegate for comparing two elements of this list.</summary>
+ /// <returns>-1, 0 or 1 for respectively smaller, equal or
larger.</returns>
+ public delegate int Compare(T a, T b);
+
public int Length
{
get { return Count(); }
@@ -256,10 +260,10 @@ public class List<T> : IEnumerable<T>, IDisposable
Handle = eina_list_sorted_insert(Handle, EinaCompareCb<T>(), ele);
}
- public void SortedInsert(Eina_Compare_Cb compareCb, T val)
+ public void SortedInsert(Compare compareCb, T val)
{
IntPtr ele = ManagedToNativeAlloc(val);
- Handle = eina_list_sorted_insert(Handle,
Marshal.GetFunctionPointerForDelegate(compareCb), ele);
+ Handle = eina_list_sorted_insert(Handle,
Marshal.GetFunctionPointerForDelegate(GetNativeCompareCb(compareCb)), ele);
}
public void Sort(int limit = 0)
@@ -267,14 +271,21 @@ public class List<T> : IEnumerable<T>, IDisposable
Handle = eina_list_sort(Handle, (uint)limit, EinaCompareCb<T>());
}
- public void Sort(Eina_Compare_Cb compareCb)
+ public void Sort(Compare compareCb)
+ {
+ Handle = eina_list_sort(Handle, 0,
Marshal.GetFunctionPointerForDelegate(GetNativeCompareCb(compareCb)));
+ }
+
+ public void Sort(int limit, Compare compareCb)
{
- Handle = eina_list_sort(Handle, 0,
Marshal.GetFunctionPointerForDelegate(compareCb));
+ Handle = eina_list_sort(Handle, (uint)limit,
Marshal.GetFunctionPointerForDelegate(GetNativeCompareCb(compareCb)));
}
- public void Sort(int limit, Eina_Compare_Cb compareCb)
+ private Eina.Callbacks.EinaCompareCb GetNativeCompareCb(Compare managedCb)
{
- Handle = eina_list_sort(Handle, (uint)limit,
Marshal.GetFunctionPointerForDelegate(compareCb));
+ return (IntPtr a, IntPtr b) => {
+ return managedCb(NativeToManaged<T>(a), NativeToManaged<T>(b));
+ };
}
public T Nth(int n)
diff --git a/src/bindings/mono/eo_mono/workaround.cs
b/src/bindings/mono/eo_mono/workaround.cs
index ff254f005d..8422062844 100644
--- a/src/bindings/mono/eo_mono/workaround.cs
+++ b/src/bindings/mono/eo_mono/workaround.cs
@@ -217,6 +217,5 @@ public struct ActionData
} // namespace Efl
// Global delegates
-public delegate int Eina_Compare_Cb(IntPtr a, IntPtr b);
public delegate void EinaFreeCb(IntPtr data);
public delegate void EvasSmartCb(IntPtr data, IntPtr obj, IntPtr event_info);
diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs
index c432033e52..cebe2ec2e6 100644
--- a/src/tests/efl_mono/Eina.cs
+++ b/src/tests/efl_mono/Eina.cs
@@ -1738,6 +1738,50 @@ class TestEinaList
}
+ public static void sorted_insert_custom_comparer_natural()
+ {
+ var lst = new Eina.List<int>();
+ Eina.List<int>.Compare comparator = (int a, int b) => a - b;
+
+ lst.SortedInsert(comparator, 1);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{1}));
+ lst.SortedInsert(comparator, 2);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{1, 2}));
+ lst.SortedInsert(comparator, 3);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{1, 2, 3}));
+ lst.SortedInsert(comparator, -1);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{-1, 1, 2, 3}));
+ }
+
+ public static void sorted_insert_custom_comparer_reversed()
+ {
+ var lst = new Eina.List<int>();
+ Eina.List<int>.Compare comparator = (int a, int b) => b - a;
+
+ lst.SortedInsert(comparator, 1);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{1}));
+ lst.SortedInsert(comparator, 2);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{2, 1}));
+ lst.SortedInsert(comparator, 3);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{3, 2, 1}));
+ lst.SortedInsert(comparator, -1);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{3, 2, 1, -1}));
+ }
+
+ public static void sorted_insert_custom_comparer_string()
+ {
+ var lst = new Eina.List<string>();
+ Eina.List<string>.Compare comparator = (string a, string b) =>
b.Length - a.Length;
+ lst.SortedInsert(comparator, "The");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"The"}));
+ lst.SortedInsert(comparator, "Quick");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"Quick","The"}));
+ lst.SortedInsert(comparator, "Brown");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"Brown", "Quick",
"The"}));
+ lst.SortedInsert(comparator, "Jumped");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"Jumped","Brown",
"Quick", "The"}));
+ }
+
public static void sort_int()
{
var lst = new Eina.List<int>();
--
