internals/src/EflSharp/EflSharp/efl/eina_inarray.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.InarrayNativeFunctions;
   9
  10 namespace Eina
  11 {
  12
  13 public static class InarrayNativeFunctions
  14 {
  15     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  16         eina_inarray_new(uint member_size, uint step);
  17     [DllImport(efl.Libs.Eina)] public static extern void
  18         eina_inarray_free(IntPtr array);
  19     [DllImport(efl.Libs.Eina)] public static extern void
  20         eina_inarray_step_set(IntPtr array, uint sizeof_eina_inarray, uint member_size, uint step);
  21     [DllImport(efl.Libs.Eina)] public static extern void
  22         eina_inarray_flush(IntPtr array);
  23     [DllImport(efl.Libs.Eina)] public static extern int
  24         eina_inarray_push(IntPtr array, IntPtr data);
  25     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  26         eina_inarray_grow(IntPtr array, uint size);
  27     [DllImport(efl.Libs.Eina)] public static extern int
  28         eina_inarray_insert(IntPtr array, IntPtr data, IntPtr compare);
  29     [DllImport(efl.Libs.Eina)] public static extern int
  30         eina_inarray_insert_sorted(IntPtr array, IntPtr data, IntPtr compare);
  31     [DllImport(efl.Libs.Eina)] public static extern int
  32         eina_inarray_remove(IntPtr array, IntPtr data);
  33     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  34         eina_inarray_pop(IntPtr array);
  35     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  36         eina_inarray_nth(IntPtr array, uint position);
  37     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  38         eina_inarray_insert_at(IntPtr array, uint position, IntPtr data);
  39     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  40         eina_inarray_alloc_at(IntPtr array, uint position, uint member_count);
  41     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  42         eina_inarray_replace_at(IntPtr array, uint position, IntPtr data);
  43     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  44         eina_inarray_remove_at(IntPtr array, uint position);
  45     [DllImport(efl.Libs.Eina)] public static extern void
  46         eina_inarray_reverse(IntPtr array);
  47     [DllImport(efl.Libs.Eina)] public static extern void
  48         eina_inarray_sort(IntPtr array, IntPtr compare);
  49     [DllImport(efl.Libs.Eina)] public static extern int
  50         eina_inarray_search(IntPtr array, IntPtr data, IntPtr compare);
  51     [DllImport(efl.Libs.Eina)] public static extern int
  52         eina_inarray_search_sorted(IntPtr array, IntPtr data, IntPtr compare);
  53     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  54         eina_inarray_foreach(IntPtr array, IntPtr function, IntPtr user_data);
  55     [DllImport(efl.Libs.Eina)] public static extern int
  56         eina_inarray_foreach_remove(IntPtr array, IntPtr match, IntPtr user_data);
  57     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  58         eina_inarray_resize(IntPtr array, uint new_size);
  59     [DllImport(efl.Libs.Eina)] public static extern uint
  60         eina_inarray_count(IntPtr array);
  61
  62     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  63         eina_inarray_iterator_new(IntPtr array);
  64     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  65         eina_inarray_iterator_reversed_new(IntPtr array);
  66     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  67         eina_inarray_accessor_new(IntPtr array);
  68 }
  69
  70 public class Inarray<T> : IEnumerable<T>, IDisposable
  71 {
  72     public static uint DefaultStep = 0;
  73
  74     public IntPtr Handle {get;set;} = IntPtr.Zero;
  75     public bool Own {get;set;}
  76     public bool OwnContent {get;set;}
  77
  78     public int Length
  79     {
  80         get { return Count(); }
  81     }
  82
  83
  84     private void InitNew(uint step)
  85     {
  86         Handle = EinaInarrayNew<T>(step);
  87         Own = true;
  88         OwnContent = true;
  89         if (Handle == IntPtr.Zero)
  90         {
  91             throw new SEHException("Could not alloc inarray");
  92         }
  93     }
  94
  95     public Inarray()
  96     {
  97         InitNew(DefaultStep);
  98     }
  99
 100     public Inarray(uint step)
 101     {
 102         InitNew(step);
 103     }
 104
 105     public Inarray(IntPtr handle, bool own)
 106     {
 107         Handle = handle;
 108         Own = own;
 109         OwnContent = own;
 110     }
 111
 112     public Inarray(IntPtr handle, bool own, bool ownContent)
 113     {
 114         Handle = handle;
 115         Own = own;
 116         OwnContent = ownContent;
 117     }
 118
 119     ~Inarray()
 120     {
 121         Dispose(false);
 122     }
 123
 124     protected virtual void Dispose(bool disposing)
 125     {
 126         IntPtr h = Handle;
 127         Handle = IntPtr.Zero;
 128         if (h == IntPtr.Zero)
 129         {
 130             return;
 131         }
 132
 133         if (OwnContent)
 134         {
 135             uint len = eina_inarray_count(h);
 136             for (uint i = 0; i < len; ++i)
 137             {
 138                 NativeFreeInplace<T>(eina_inarray_nth(h, i));
 139             }
 140         }
 141
 142         if (Own)
 143         {
 144             if (disposing)
 145             {
 146                 eina_inarray_free(h);
 147             }
 148             else
 149             {
 150                 Efl.Eo.Globals.ThreadSafeFreeCbExec(eina_inarray_free, h);
 151             }
 152         }
 153     }
 154
 155     public void Dispose()
 156     {
 157         Dispose(true);
 158         GC.SuppressFinalize(this);
 159     }
 160
 161     public void Free()
 162     {
 163         Dispose();
 164     }
 165
 166     public IntPtr Release()
 167     {
 168         IntPtr h = Handle;
 169         Handle = IntPtr.Zero;
 170         return h;
 171     }
 172
 173     private void FreeElementsIfOwned()
 174     {
 175         if (OwnContent)
 176         {
 177             int len = Length;
 178             for (int i = 0; i < len; ++i)
 179             {
 180                 NativeFreeInplace<T>(eina_inarray_nth(Handle, (uint)i));
 181             }
 182         }
 183     }
 184
 185     public void Flush()
 186     {
 187         FreeElementsIfOwned();
 188         eina_inarray_flush(Handle);
 189     }
 190
 191     public int Count()
 192     {
 193         return (int)eina_inarray_count(Handle);
 194     }
 195
 196     public void SetOwnership(bool ownAll)
 197     {
 198         Own = ownAll;
 199         OwnContent = ownAll;
 200     }
 201
 202     public void SetOwnership(bool own, bool ownContent)
 203     {
 204         Own = own;
 205         OwnContent = ownContent;
 206     }
 207
 208     public int Push(T val)
 209     {
 210         IntPtr ele = IntPtr.Zero;
 211         GCHandle gch = GCHandle.Alloc(ele, GCHandleType.Pinned);
 212         IntPtr ind = gch.AddrOfPinnedObject();
 213
 214         ManagedToNativeCopyTo(val, ind);
 215
 216         var r = eina_inarray_push(Handle, ind);
 217         if (r == -1)
 218         {
 219             NativeFreeInplace<T>(ele);
 220         }
 221
 222         ResidueFreeInplace<T>(ele);
 223         gch.Free();
 224         return r;
 225     }
 226
 227 // TODO ???
 228 //     public void Add(T val)
 229 //     {
 230 //         if (!Push(val))
 231 //         {
 232 //             throw;
 233 //         }
 234 //     }
 235
 236     public T Pop()
 237     {
 238         IntPtr ele = eina_inarray_pop(Handle);
 239         var r = NativeToManagedInplace<T>(ele);
 240         if (OwnContent && ele != IntPtr.Zero)
 241         {
 242             NativeFreeInplace<T>(ele);
 243         }
 244
 245         return r;
 246     }
 247
 248     public T Nth(uint idx)
 249     {
 250         IntPtr ele = eina_inarray_nth(Handle, idx);
 251         return NativeToManagedInplace<T>(ele);
 252     }
 253
 254     public T At(int idx)
 255     {
 256         return Nth((uint)idx);
 257     }
 258
 259     public bool InsertAt(uint idx, T val)
 260     {
 261         IntPtr ele = IntPtr.Zero;
 262         GCHandle gch = GCHandle.Alloc(ele, GCHandleType.Pinned);
 263         IntPtr ind = gch.AddrOfPinnedObject();
 264
 265         ManagedToNativeCopyTo(val, ind);
 266
 267         var r = eina_inarray_insert_at(Handle, idx, ind);
 268         if (!r)
 269         {
 270             NativeFreeInplace<T>(ele);
 271         }
 272
 273         ResidueFreeInplace<T>(ele);
 274         return r;
 275     }
 276
 277     public bool ReplaceAt(uint idx, T val)
 278     {
 279         var old = eina_inarray_nth(Handle, idx);
 280         if (old == IntPtr.Zero)
 281         {
 282             return false;
 283         }
 284
 285         if (OwnContent)
 286         {
 287             NativeFreeInplace<T>(old);
 288         }
 289
 290         var ele = IntPtr.Zero;
 291         GCHandle gch = GCHandle.Alloc(ele, GCHandleType.Pinned);
 292         IntPtr ind = gch.AddrOfPinnedObject();
 293
 294         ManagedToNativeCopyTo(val, ind);
 295
 296         var r = eina_inarray_replace_at(Handle, idx, ind);
 297         ResidueFreeInplace<T>(ele);
 298         return r;
 299     }
 300
 301     public T this[int idx]
 302     {
 303         get
 304         {
 305             return At(idx);
 306         }
 307         set
 308         {
 309             ReplaceAt((uint)idx, value);
 310         }
 311     }
 312
 313     public bool RemoveAt(uint idx)
 314     {
 315         IntPtr ele = eina_inarray_nth(Handle, idx);
 316         if (ele == IntPtr.Zero)
 317         {
 318             return false;
 319         }
 320
 321         if (OwnContent)
 322         {
 323             NativeFreeInplace<T>(ele);
 324         }
 325
 326         return eina_inarray_remove_at(Handle, idx);
 327     }
 328
 329     public void Reverse()
 330     {
 331         eina_inarray_reverse(Handle);
 332     }
 333
 334     public T[] ToArray()
 335     {
 336         int len = Length;
 337         var managed = new T[len];
 338         for (int i = 0; i < len; ++i)
 339         {
 340             managed[i] = At(i);
 341         }
 342
 343         return managed;
 344     }
 345
 346     public bool Append(T[] values)
 347     {
 348         foreach (T v in values)
 349         {
 350             if (Push(v) == -1)
 351             {
 352                 return false;
 353             }
 354         }
 355
 356         return true;
 357     }
 358
 359     public Eina.Iterator<T> GetIterator()
 360     {
 361         return new Eina.Iterator<T>(eina_inarray_iterator_new(Handle), true, false);
 362     }
 363
 364     public Eina.Iterator<T> GetReversedIterator()
 365     {
 366         return new Eina.Iterator<T>(eina_inarray_iterator_reversed_new(Handle), true, false);
 367     }
 368
 369     public IEnumerator<T> GetEnumerator()
 370     {
 371         int len = Length;
 372         for (int i = 0; i < len; ++i)
 373         {
 374             yield return At(i);
 375         }
 376     }
 377
 378     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 379     {
 380         return this.GetEnumerator();
 381     }
 382
 383     /// <summary> Gets an Accessor for this Array.</summary>
 384     public Eina.Accessor<T> GetAccessor()
 385     {
 386         return new Eina.AccessorInArray<T>(eina_inarray_accessor_new(Handle), Ownership.Managed);
 387     }
 388 }
 389
 390 }