internals/src/EflSharp/EflSharp/efl/eina_list.cs

   1 #pragma warning disable 1591
   2
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6
   7 using static Eina.TraitFunctions;
   8 using static Eina.ListNativeFunctions;
   9 using Eina.Callbacks;
  10
  11 namespace Eina
  12 {
  13
  14 public static class ListNativeFunctions
  15 {
  16     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  17         eina_list_append(IntPtr list, IntPtr data);
  18     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  19         eina_list_prepend(IntPtr list, IntPtr data);
  20     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  21         eina_list_append_relative(IntPtr list, IntPtr data, IntPtr relative);
  22     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  23         eina_list_append_relative_list(IntPtr list, IntPtr data, IntPtr relative);
  24     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  25         eina_list_prepend_relative(IntPtr list, IntPtr data, IntPtr relative);
  26     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  27         eina_list_prepend_relative_list(IntPtr list, IntPtr data, IntPtr relative);
  28     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  29         eina_list_sorted_insert(IntPtr list, IntPtr func, IntPtr data);
  30     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  31         eina_list_remove(IntPtr list, IntPtr data);
  32     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  33         eina_list_remove_list(IntPtr list, IntPtr remove_list);
  34     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  35         eina_list_promote_list(IntPtr list, IntPtr move_list);
  36     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  37         eina_list_demote_list(IntPtr list, IntPtr move_list);
  38     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  39         eina_list_data_find(IntPtr list, IntPtr data);
  40     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  41         eina_list_data_find_list(IntPtr list, IntPtr data);
  42     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  43         eina_list_move(ref IntPtr to, ref IntPtr from, IntPtr data);
  44     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  45         eina_list_move_list(ref IntPtr to, ref IntPtr from, IntPtr data);
  46     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  47         eina_list_free(IntPtr list);
  48     [DllImport(efl.Libs.CustomExports)] public static extern void
  49         efl_mono_thread_safe_eina_list_free(IntPtr list);
  50     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  51         eina_list_nth(IntPtr list, uint n);
  52     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  53         eina_list_nth_list(IntPtr list, uint n);
  54     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  55         eina_list_reverse(IntPtr list);
  56     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  57         eina_list_reverse_clone(IntPtr list);
  58     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  59         eina_list_clone(IntPtr list);
  60     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  61         eina_list_sort(IntPtr list, uint limit, IntPtr func);
  62     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  63         eina_list_shuffle(IntPtr list, IntPtr func);
  64     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  65         eina_list_merge(IntPtr left, IntPtr right);
  66     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  67         eina_list_sorted_merge(IntPtr left, IntPtr right, IntPtr func);
  68     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  69         eina_list_split_list(IntPtr list, IntPtr relative, ref IntPtr right);
  70     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  71         eina_list_search_sorted_near_list(IntPtr list, IntPtr func, IntPtr data, IntPtr result_cmp);
  72     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  73         eina_list_search_sorted_list(IntPtr list, IntPtr func, IntPtr data);
  74     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  75         eina_list_search_sorted(IntPtr list, IntPtr func, IntPtr data);
  76     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  77         eina_list_search_unsorted_list(IntPtr list, IntPtr func, IntPtr data);
  78     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  79         eina_list_search_unsorted(IntPtr list, IntPtr func, IntPtr data);
  80
  81     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  82         eina_list_iterator_new(IntPtr list);
  83     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  84         eina_list_iterator_reversed_new(IntPtr list);
  85     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  86         eina_list_accessor_new(IntPtr list);
  87     [DllImport(efl.Libs.Eina)] public static extern int
  88         eina_list_data_idx(IntPtr list, IntPtr data);
  89
  90
  91     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  92         eina_list_last_custom_export_mono(IntPtr list);
  93     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  94         eina_list_next_custom_export_mono(IntPtr list);
  95     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  96         eina_list_prev_custom_export_mono(IntPtr list);
  97     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  98         eina_list_data_get_custom_export_mono(IntPtr list);
  99     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
 100         eina_list_data_set_custom_export_mono(IntPtr list, IntPtr data);
 101     [DllImport(efl.Libs.CustomExports)] public static extern uint
 102         eina_list_count_custom_export_mono(IntPtr list);
 103     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
 104         eina_list_last_data_get_custom_export_mono(IntPtr list);
 105 }
 106
 107 public class List<T> : IEnumerable<T>, IDisposable
 108 {
 109     public IntPtr Handle {get;set;} = IntPtr.Zero;
 110     public bool Own {get;set;}
 111     public bool OwnContent {get;set;}
 112
 113     public int Length
 114     {
 115         get { return Count(); }
 116     }
 117
 118
 119     private void InitNew()
 120     {
 121         Handle = IntPtr.Zero;
 122         Own = true;
 123         OwnContent = true;
 124     }
 125
 126     private IntPtr InternalLast()
 127     {
 128         return eina_list_last_custom_export_mono(Handle);
 129     }
 130
 131     private static IntPtr InternalNext(IntPtr list)
 132     {
 133         return eina_list_next_custom_export_mono(list);
 134     }
 135
 136     private static IntPtr InternalPrev(IntPtr list)
 137     {
 138         return eina_list_prev_custom_export_mono(list);
 139     }
 140
 141     private static IntPtr InternalDataGet(IntPtr list)
 142     {
 143         return eina_list_data_get_custom_export_mono(list);
 144     }
 145
 146     private static IntPtr InternalDataSet(IntPtr list, IntPtr data)
 147     {
 148         return eina_list_data_set_custom_export_mono(list, data);
 149     }
 150
 151
 152     public List()
 153     {
 154         InitNew();
 155     }
 156
 157     public List(IntPtr handle, bool own)
 158     {
 159         Handle = handle;
 160         Own = own;
 161         OwnContent = own;
 162     }
 163
 164     public List(IntPtr handle, bool own, bool ownContent)
 165     {
 166         Handle = handle;
 167         Own = own;
 168         OwnContent = ownContent;
 169     }
 170
 171     ~List()
 172     {
 173         Dispose(false);
 174     }
 175
 176     protected virtual void Dispose(bool disposing)
 177     {
 178         IntPtr h = Handle;
 179         Handle = IntPtr.Zero;
 180         if (h == IntPtr.Zero)
 181         {
 182             return;
 183         }
 184
 185         if (OwnContent)
 186         {
 187             for (IntPtr curr = h; curr != IntPtr.Zero; curr = InternalNext(curr))
 188             {
 189                 NativeFree<T>(InternalDataGet(curr));
 190             }
 191         }
 192
 193         if (Own)
 194         {
 195             if (disposing)
 196             {
 197                 eina_list_free(h);
 198             }
 199             else
 200             {
 201                 efl_mono_thread_safe_eina_list_free(h);
 202             }
 203         }
 204     }
 205
 206     public void Dispose()
 207     {
 208         Dispose(true);
 209         GC.SuppressFinalize(this);
 210     }
 211
 212     public void Free()
 213     {
 214         Dispose();
 215     }
 216
 217     public IntPtr Release()
 218     {
 219         IntPtr h = Handle;
 220         Handle = IntPtr.Zero;
 221         return h;
 222     }
 223
 224     public void SetOwnership(bool ownAll)
 225     {
 226         Own = ownAll;
 227         OwnContent = ownAll;
 228     }
 229
 230     public void SetOwnership(bool own, bool ownContent)
 231     {
 232         Own = own;
 233         OwnContent = ownContent;
 234     }
 235
 236     public int Count()
 237     {
 238         return (int)eina_list_count_custom_export_mono(Handle);
 239     }
 240
 241     public void Append(T val)
 242     {
 243         IntPtr ele = ManagedToNativeAlloc(val);
 244         Handle = eina_list_append(Handle, ele);
 245     }
 246
 247     public void Prepend(T val)
 248     {
 249         IntPtr ele = ManagedToNativeAlloc(val);
 250         Handle = eina_list_prepend(Handle, ele);
 251     }
 252
 253     public void SortedInsert(T val)
 254     {
 255         IntPtr ele = ManagedToNativeAlloc(val);
 256         Handle = eina_list_sorted_insert(Handle, EinaCompareCb<T>(), ele);
 257     }
 258
 259     public void SortedInsert(Eina_Compare_Cb compareCb, T val)
 260     {
 261         IntPtr ele = ManagedToNativeAlloc(val);
 262         Handle = eina_list_sorted_insert(Handle, Marshal.GetFunctionPointerForDelegate(compareCb), ele);
 263     }
 264
 265     public void Sort(int limit = 0)
 266     {
 267         Handle = eina_list_sort(Handle, (uint)limit, EinaCompareCb<T>());
 268     }
 269
 270     public void Sort(Eina_Compare_Cb compareCb)
 271     {
 272         Handle = eina_list_sort(Handle, 0, Marshal.GetFunctionPointerForDelegate(compareCb));
 273     }
 274
 275     public void Sort(int limit, Eina_Compare_Cb compareCb)
 276     {
 277         Handle = eina_list_sort(Handle, (uint)limit, Marshal.GetFunctionPointerForDelegate(compareCb));
 278     }
 279
 280     public T Nth(int n)
 281     {
 282         // TODO: check bounds ???
 283         IntPtr ele = eina_list_nth(Handle, (uint)n);
 284         return NativeToManaged<T>(ele);
 285     }
 286
 287     public void DataSet(int idx, T val)
 288     {
 289         IntPtr pos = eina_list_nth_list(Handle, (uint)idx);
 290         if (pos == IntPtr.Zero)
 291         {
 292             throw new IndexOutOfRangeException();
 293         }
 294
 295         if (OwnContent)
 296         {
 297             NativeFree<T>(InternalDataGet(pos));
 298         }
 299
 300         IntPtr ele = ManagedToNativeAlloc(val);
 301         InternalDataSet(pos, ele);
 302     }
 303
 304     public T this[int idx]
 305     {
 306         get
 307         {
 308             return Nth(idx);
 309         }
 310         set
 311         {
 312             DataSet(idx, value);
 313         }
 314     }
 315
 316     public T LastDataGet()
 317     {
 318         IntPtr ele = eina_list_last_data_get_custom_export_mono(Handle);
 319         return NativeToManaged<T>(ele);
 320     }
 321
 322     public List<T> Reverse()
 323     {
 324         Handle = eina_list_reverse(Handle);
 325         return this;
 326     }
 327
 328     public void Shuffle()
 329     {
 330         Handle = eina_list_shuffle(Handle, IntPtr.Zero);
 331     }
 332
 333     public T[] ToArray()
 334     {
 335         var managed = new T[Count()];
 336         int i = 0;
 337         for (IntPtr curr = Handle; curr != IntPtr.Zero; curr = InternalNext(curr), ++i)
 338         {
 339             managed[i] = NativeToManaged<T>(InternalDataGet(curr));
 340         }
 341
 342         return managed;
 343     }
 344
 345     public void AppendArray(T[] values)
 346     {
 347         foreach (T v in values)
 348         {
 349             Append(v);
 350         }
 351     }
 352
 353
 354     public Eina.Iterator<T> GetIterator()
 355     {
 356         return new Eina.Iterator<T>(eina_list_iterator_new(Handle), true);
 357     }
 358
 359     public Eina.Iterator<T> GetReversedIterator()
 360     {
 361         return new Eina.Iterator<T>(eina_list_iterator_reversed_new(Handle), true);
 362     }
 363
 364     public IEnumerator<T> GetEnumerator()
 365     {
 366         for (IntPtr curr = Handle; curr != IntPtr.Zero; curr = InternalNext(curr))
 367         {
 368             yield return NativeToManaged<T>(InternalDataGet(curr));
 369         }
 370     }
 371
 372     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 373     {
 374         return this.GetEnumerator();
 375     }
 376
 377     /// <summary> Gets an Accessor for this List.</summary>
 378     public Eina.Accessor<T> GetAccessor()
 379     {
 380         return new Eina.Accessor<T>(eina_list_accessor_new(Handle), Ownership.Managed);
 381     }
 382 }
 383
 384 }