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             eina_inarray_free(h);
 145         }
 146     }
 147
 148     public void Dispose()
 149     {
 150         Dispose(true);
 151         GC.SuppressFinalize(this);
 152     }
 153
 154     public void Free()
 155     {
 156         Dispose();
 157     }
 158
 159     public IntPtr Release()
 160     {
 161         IntPtr h = Handle;
 162         Handle = IntPtr.Zero;
 163         return h;
 164     }
 165
 166     private void FreeElementsIfOwned()
 167     {
 168         if (OwnContent)
 169         {
 170             int len = Length;
 171             for (int i = 0; i < len; ++i)
 172             {
 173                 NativeFreeInplace<T>(eina_inarray_nth(Handle, (uint)i));
 174             }
 175         }
 176     }
 177
 178     public void Flush()
 179     {
 180         FreeElementsIfOwned();
 181         eina_inarray_flush(Handle);
 182     }
 183
 184     public int Count()
 185     {
 186         return (int)eina_inarray_count(Handle);
 187     }
 188
 189     public void SetOwnership(bool ownAll)
 190     {
 191         Own = ownAll;
 192         OwnContent = ownAll;
 193     }
 194
 195     public void SetOwnership(bool own, bool ownContent)
 196     {
 197         Own = own;
 198         OwnContent = ownContent;
 199     }
 200
 201     public int Push(T val)
 202     {
 203         IntPtr ele = IntPtr.Zero;
 204         GCHandle gch = GCHandle.Alloc(ele, GCHandleType.Pinned);
 205         IntPtr ind = gch.AddrOfPinnedObject();
 206
 207         ManagedToNativeCopyTo(val, ind);
 208
 209         var r = eina_inarray_push(Handle, ind);
 210         if (r == -1)
 211         {
 212             NativeFreeInplace<T>(ele);
 213         }
 214
 215         ResidueFreeInplace<T>(ele);
 216         gch.Free();
 217         return r;
 218     }
 219
 220 // TODO ???
 221 //     public void Add(T val)
 222 //     {
 223 //         if (!Push(val))
 224 //         {
 225 //             throw;
 226 //         }
 227 //     }
 228
 229     public T Pop()
 230     {
 231         IntPtr ele = eina_inarray_pop(Handle);
 232         var r = NativeToManagedInplace<T>(ele);
 233         if (OwnContent && ele != IntPtr.Zero)
 234         {
 235             NativeFreeInplace<T>(ele);
 236         }
 237
 238         return r;
 239     }
 240
 241     public T Nth(uint idx)
 242     {
 243         IntPtr ele = eina_inarray_nth(Handle, idx);
 244         return NativeToManagedInplace<T>(ele);
 245     }
 246
 247     public T At(int idx)
 248     {
 249         return Nth((uint)idx);
 250     }
 251
 252     public bool InsertAt(uint idx, T val)
 253     {
 254         IntPtr ele = IntPtr.Zero;
 255         GCHandle gch = GCHandle.Alloc(ele, GCHandleType.Pinned);
 256         IntPtr ind = gch.AddrOfPinnedObject();
 257
 258         ManagedToNativeCopyTo(val, ind);
 259
 260         var r = eina_inarray_insert_at(Handle, idx, ind);
 261         if (!r)
 262         {
 263             NativeFreeInplace<T>(ele);
 264         }
 265
 266         ResidueFreeInplace<T>(ele);
 267         return r;
 268     }
 269
 270     public bool ReplaceAt(uint idx, T val)
 271     {
 272         var old = eina_inarray_nth(Handle, idx);
 273         if (old == IntPtr.Zero)
 274         {
 275             return false;
 276         }
 277
 278         if (OwnContent)
 279         {
 280             NativeFreeInplace<T>(old);
 281         }
 282
 283         var ele = IntPtr.Zero;
 284         GCHandle gch = GCHandle.Alloc(ele, GCHandleType.Pinned);
 285         IntPtr ind = gch.AddrOfPinnedObject();
 286
 287         ManagedToNativeCopyTo(val, ind);
 288
 289         var r = eina_inarray_replace_at(Handle, idx, ind);
 290         ResidueFreeInplace<T>(ele);
 291         return r;
 292     }
 293
 294     public T this[int idx]
 295     {
 296         get
 297         {
 298             return At(idx);
 299         }
 300         set
 301         {
 302             ReplaceAt((uint)idx, value);
 303         }
 304     }
 305
 306     public bool RemoveAt(uint idx)
 307     {
 308         IntPtr ele = eina_inarray_nth(Handle, idx);
 309         if (ele == IntPtr.Zero)
 310         {
 311             return false;
 312         }
 313
 314         if (OwnContent)
 315         {
 316             NativeFreeInplace<T>(ele);
 317         }
 318
 319         return eina_inarray_remove_at(Handle, idx);
 320     }
 321
 322     public void Reverse()
 323     {
 324         eina_inarray_reverse(Handle);
 325     }
 326
 327     public T[] ToArray()
 328     {
 329         int len = Length;
 330         var managed = new T[len];
 331         for (int i = 0; i < len; ++i)
 332         {
 333             managed[i] = At(i);
 334         }
 335
 336         return managed;
 337     }
 338
 339     public bool Append(T[] values)
 340     {
 341         foreach (T v in values)
 342         {
 343             if (Push(v) == -1)
 344             {
 345                 return false;
 346             }
 347         }
 348
 349         return true;
 350     }
 351
 352     public Eina.Iterator<T> GetIterator()
 353     {
 354         return new Eina.Iterator<T>(eina_inarray_iterator_new(Handle), true, false);
 355     }
 356
 357     public Eina.Iterator<T> GetReversedIterator()
 358     {
 359         return new Eina.Iterator<T>(eina_inarray_iterator_reversed_new(Handle), true, false);
 360     }
 361
 362     public IEnumerator<T> GetEnumerator()
 363     {
 364         int len = Length;
 365         for (int i = 0; i < len; ++i)
 366         {
 367             yield return At(i);
 368         }
 369     }
 370
 371     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 372     {
 373         return this.GetEnumerator();
 374     }
 375
 376     /// <summary> Gets an Accessor for this Array.</summary>
 377     public Eina.Accessor<T> GetAccessor()
 378     {
 379         return new Eina.AccessorInArray<T>(eina_inarray_accessor_new(Handle), Ownership.Managed);
 380     }
 381 }
 382
 383 }