internals/src/EflSharp/EflSharp/efl/eina_inlist.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.InlistNativeFunctions;
   9 using Eina.Callbacks;
  10
  11 namespace Eina
  12 {
  13
  14 public static class InlistNativeFunctions
  15 {
  16     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  17         eina_inlist_append(IntPtr in_list, IntPtr in_item);
  18
  19     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  20         eina_inlist_prepend(IntPtr in_list, IntPtr in_item);
  21
  22     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  23         eina_inlist_append_relative(IntPtr in_list, IntPtr in_item, IntPtr in_relative);
  24
  25     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  26         eina_inlist_prepend_relative(IntPtr in_list, IntPtr in_item, IntPtr in_relative);
  27
  28     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  29         eina_inlist_remove(IntPtr in_list, IntPtr in_item);
  30
  31     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  32         eina_inlist_find(IntPtr in_list, IntPtr in_item);
  33
  34     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  35         eina_inlist_promote(IntPtr list, IntPtr item);
  36
  37     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  38         eina_inlist_demote(IntPtr list, IntPtr item);
  39
  40     [DllImport(efl.Libs.Eina)] public static extern uint
  41         eina_inlist_count(IntPtr list);
  42
  43     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  44         eina_inlist_iterator_new(IntPtr in_list);
  45
  46     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  47         eina_inlist_accessor_new(IntPtr in_list);
  48
  49     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  50         eina_inlist_sorted_insert(IntPtr list, IntPtr item, IntPtr func);
  51
  52     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  53         eina_inlist_sorted_state_new();
  54
  55     [DllImport(efl.Libs.Eina)] public static extern int
  56         eina_inlist_sorted_state_init(IntPtr state, IntPtr list);
  57
  58     [DllImport(efl.Libs.Eina)] public static extern void
  59         eina_inlist_sorted_state_free(IntPtr state);
  60
  61     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  62         eina_inlist_sorted_state_insert(IntPtr list, IntPtr item, IntPtr func, IntPtr state);
  63
  64     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  65         eina_inlist_sort(IntPtr head, IntPtr func);
  66
  67
  68     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  69         eina_inlist_first_custom_export_mono(IntPtr list);
  70     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  71         eina_inlist_last_custom_export_mono(IntPtr list);
  72
  73
  74     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  75         eina_inlist_next_custom_export_mono(IntPtr list);
  76     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  77         eina_inlist_prev_custom_export_mono(IntPtr list);
  78
  79     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  80         eina_inlist_iterator_wrapper_new_custom_export_mono(IntPtr in_list);
  81 }
  82
  83 public class Inlist<T> : IEnumerable<T>, IDisposable
  84 {
  85     public IntPtr Handle {get;set;} = IntPtr.Zero;
  86     public bool Own {get;set;}
  87     public bool OwnContent {get;set;}
  88
  89     public int Length
  90     {
  91         get { return Count(); }
  92     }
  93
  94
  95     private void InitNew()
  96     {
  97         Handle = IntPtr.Zero;
  98         Own = true;
  99         OwnContent = true;
 100     }
 101
 102     private IntPtr InternalFirst()
 103     {
 104         return eina_inlist_first_custom_export_mono(Handle);
 105     }
 106
 107     private IntPtr InternalLast()
 108     {
 109         return eina_inlist_last_custom_export_mono(Handle);
 110     }
 111
 112     private IntPtr InternalAt(int idx)
 113     {
 114         if (idx < 0)
 115         {
 116             return IntPtr.Zero;
 117         }
 118
 119         IntPtr curr = Handle;
 120         for (int n = 0; n != idx && curr != IntPtr.Zero; ++n)
 121         {
 122             curr = InternalNext(curr);
 123         }
 124
 125         return curr;
 126     }
 127
 128     private static IntPtr InternalNext(IntPtr inlist)
 129     {
 130         return eina_inlist_next_custom_export_mono(inlist);
 131     }
 132
 133     private static IntPtr InternalPrev(IntPtr inlist)
 134     {
 135         return eina_inlist_prev_custom_export_mono(inlist);
 136     }
 137
 138
 139     public Inlist()
 140     {
 141         InitNew();
 142     }
 143
 144     public Inlist(IntPtr handle, bool own)
 145     {
 146         Handle = handle;
 147         Own = own;
 148         OwnContent = own;
 149     }
 150
 151     public Inlist(IntPtr handle, bool own, bool ownContent)
 152     {
 153         Handle = handle;
 154         Own = own;
 155         OwnContent = ownContent;
 156     }
 157
 158     ~Inlist()
 159     {
 160         Dispose(false);
 161     }
 162
 163     protected virtual void Dispose(bool disposing)
 164     {
 165         IntPtr h = Handle;
 166         Handle = IntPtr.Zero;
 167         if (h == IntPtr.Zero)
 168         {
 169             return;
 170         }
 171
 172         if (OwnContent)
 173         {
 174             for (IntPtr curr = h; curr != IntPtr.Zero; curr = InternalNext(curr))
 175             {
 176                 NativeFreeInlistNodeElement<T>(curr);
 177             }
 178         }
 179
 180         if (Own)
 181         {
 182             while (h != IntPtr.Zero)
 183             {
 184                 var aux = h;
 185                 h = eina_inlist_remove(h, h);
 186                 NativeFreeInlistNode<T>(aux, false);
 187             }
 188         }
 189     }
 190
 191     public void Dispose()
 192     {
 193         Dispose(true);
 194         GC.SuppressFinalize(this);
 195     }
 196
 197     public void Free()
 198     {
 199         Dispose();
 200     }
 201
 202     public IntPtr Release()
 203     {
 204         IntPtr h = Handle;
 205         Handle = IntPtr.Zero;
 206         return h;
 207     }
 208
 209     public void SetOwnership(bool ownAll)
 210     {
 211         Own = ownAll;
 212         OwnContent = ownAll;
 213     }
 214
 215     public void SetOwnership(bool own, bool ownContent)
 216     {
 217         Own = own;
 218         OwnContent = ownContent;
 219     }
 220
 221     public int Count()
 222     {
 223         return (int)eina_inlist_count(Handle);
 224     }
 225
 226     public void Clean()
 227     {
 228         while (Handle != IntPtr.Zero)
 229         {
 230             var aux = Handle;
 231             Handle = eina_inlist_remove(Handle, Handle);
 232             NativeFreeInlistNode<T>(aux, OwnContent);
 233         }
 234     }
 235
 236     public void Append(T val)
 237     {
 238         IntPtr node = ManagedToNativeAllocInlistNode(val);
 239         Handle = eina_inlist_append(Handle, node);
 240     }
 241
 242     public void Prepend(T val)
 243     {
 244         IntPtr node = ManagedToNativeAllocInlistNode(val);
 245         Handle = eina_inlist_prepend(Handle, node);
 246     }
 247
 248     public void Remove(int idx)
 249     {
 250         IntPtr node = InternalAt(idx);
 251         Handle = eina_inlist_remove(Handle, node);
 252         NativeFreeInlistNode<T>(node, OwnContent);
 253     }
 254
 255     public T At(int idx)
 256     {
 257         IntPtr node = InternalAt(idx);
 258         if (node == IntPtr.Zero)
 259         {
 260             throw new IndexOutOfRangeException();
 261         }
 262
 263         return NativeToManagedInlistNode<T>(node);
 264     }
 265
 266     public void DataSet(int idx, T val)
 267     {
 268         IntPtr old = InternalAt(idx);
 269         if (old == IntPtr.Zero)
 270         {
 271             throw new IndexOutOfRangeException();
 272         }
 273
 274         IntPtr new_node = ManagedToNativeAllocInlistNode(val);
 275
 276         Handle = eina_inlist_append_relative(Handle, new_node, old);
 277         Handle = eina_inlist_remove(Handle, old);
 278
 279         NativeFreeInlistNode<T>(old, OwnContent);
 280     }
 281
 282     public T this[int idx]
 283     {
 284         get
 285         {
 286             return At(idx);
 287         }
 288         set
 289         {
 290             DataSet(idx, value);
 291         }
 292     }
 293
 294     public T[] ToArray()
 295     {
 296         var managed = new T[Count()];
 297         int i = 0;
 298         for (IntPtr curr = Handle; curr != IntPtr.Zero; ++i, curr = InternalNext(curr))
 299         {
 300             managed[i] = NativeToManagedInlistNode<T>(curr);
 301         }
 302
 303         return managed;
 304     }
 305
 306     public void AppendArray(T[] values)
 307     {
 308         foreach (T v in values)
 309         {
 310             Append(v);
 311         }
 312     }
 313
 314
 315     public Eina.Iterator<T> GetIterator()
 316     {
 317         return new Eina.Iterator<T>(eina_inlist_iterator_wrapper_new_custom_export_mono(Handle), true);
 318     }
 319
 320     public IEnumerator<T> GetEnumerator()
 321     {
 322         for (IntPtr curr = Handle; curr != IntPtr.Zero; curr = InternalNext(curr))
 323         {
 324             yield return NativeToManagedInlistNode<T>(curr);
 325         }
 326     }
 327
 328     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 329     {
 330         return this.GetEnumerator();
 331     }
 332
 333     /// <summary> Gets an Accessor for this List.</summary>
 334     public Eina.Accessor<T> GetAccessor()
 335     {
 336         return new Eina.AccessorInList<T>(eina_inlist_accessor_new(Handle), Ownership.Managed);
 337     }
 338 }
 339
 340 }