internals/src/EflSharp/EflSharp/efl/eina_array.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.ArrayNativeFunctions;
   9
  10 namespace Eina
  11 {
  12
  13 public static class ArrayNativeFunctions
  14 {
  15     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  16         eina_array_new(uint step);
  17     [DllImport(efl.Libs.Eina)] public static extern void
  18         eina_array_free(IntPtr array);
  19     [DllImport(efl.Libs.Eina)] public static extern void
  20         eina_array_flush(IntPtr array);
  21     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  22         eina_array_remove(IntPtr array, IntPtr keep, IntPtr gdata);
  23     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  24         eina_array_push(IntPtr array, IntPtr data);
  25
  26     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  27         eina_array_iterator_new(IntPtr array);
  28     [DllImport(efl.Libs.Eina)] public static extern IntPtr
  29         eina_array_accessor_new(IntPtr array);
  30
  31     [DllImport(efl.Libs.CustomExports)] public static extern void
  32         eina_array_clean_custom_export_mono(IntPtr array);
  33     [DllImport(efl.Libs.CustomExports)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  34         eina_array_push_custom_export_mono(IntPtr array, IntPtr data);
  35     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  36         eina_array_pop_custom_export_mono(IntPtr array);
  37     [DllImport(efl.Libs.CustomExports)] public static extern IntPtr
  38         eina_array_data_get_custom_export_mono(IntPtr array, uint idx);
  39     [DllImport(efl.Libs.CustomExports)] public static extern void
  40         eina_array_data_set_custom_export_mono(IntPtr array, uint idx, IntPtr data);
  41     [DllImport(efl.Libs.CustomExports)] public static extern uint
  42         eina_array_count_custom_export_mono(IntPtr array);
  43
  44     [DllImport(efl.Libs.CustomExports)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
  45         eina_array_foreach_custom_export_mono(IntPtr array, IntPtr cb, IntPtr fdata);
  46 }
  47
  48 public class Array<T> : IEnumerable<T>, IDisposable
  49 {
  50     public static uint DefaultStep = 32;
  51
  52     public IntPtr Handle {get;set;} = IntPtr.Zero;
  53     public bool Own {get;set;}
  54     public bool OwnContent {get;set;}
  55
  56     public int Length
  57     {
  58         get { return Count(); }
  59     }
  60
  61
  62     private void InitNew(uint step)
  63     {
  64         Handle = eina_array_new(step);
  65         Own = true;
  66         OwnContent = true;
  67         if (Handle == IntPtr.Zero)
  68         {
  69             throw new SEHException("Could not alloc array");
  70         }
  71     }
  72
  73     internal bool InternalPush(IntPtr ele)
  74     {
  75         return eina_array_push_custom_export_mono(Handle, ele);
  76     }
  77
  78     internal IntPtr InternalPop()
  79     {
  80         return eina_array_pop_custom_export_mono(Handle);
  81     }
  82
  83     internal IntPtr InternalDataGet(int idx)
  84     {
  85         return eina_array_data_get_custom_export_mono(Handle, (uint)idx); // TODO: Check bounds ???
  86     }
  87
  88     internal void InternalDataSet(int idx, IntPtr ele)
  89     {
  90         eina_array_data_set_custom_export_mono(Handle, (uint)idx, ele); // TODO: Check bounds ???
  91     }
  92
  93     public Array()
  94     {
  95         InitNew(DefaultStep);
  96     }
  97
  98     public Array(uint step)
  99     {
 100         InitNew(step);
 101     }
 102
 103     public Array(IntPtr handle, bool own)
 104     {
 105         if (handle == IntPtr.Zero)
 106         {
 107             throw new ArgumentNullException("Handle can't be null");
 108         }
 109
 110         Handle = handle;
 111         Own = own;
 112         OwnContent = own;
 113     }
 114
 115     public Array(IntPtr handle, bool own, bool ownContent)
 116     {
 117         if (handle == IntPtr.Zero)
 118         {
 119             throw new ArgumentNullException("Handle can't be null");
 120         }
 121
 122         Handle = handle;
 123         Own = own;
 124         OwnContent = ownContent;
 125     }
 126
 127     ~Array()
 128     {
 129         Dispose(false);
 130     }
 131
 132     protected virtual void Dispose(bool disposing)
 133     {
 134         IntPtr h = Handle;
 135         Handle = IntPtr.Zero;
 136         if (h == IntPtr.Zero)
 137         {
 138             return;
 139         }
 140
 141         if (Own && OwnContent)
 142         {
 143             int len = (int)eina_array_count_custom_export_mono(h);
 144             for (int i = 0; i < len; ++i)
 145             {
 146                 NativeFree<T>(eina_array_data_get_custom_export_mono(h, (uint)i));
 147             }
 148         }
 149
 150         if (Own)
 151         {
 152             if (disposing)
 153             {
 154                 eina_array_free(h);
 155             }
 156             else
 157             {
 158                 Efl.Eo.Globals.ThreadSafeFreeCbExec(eina_array_free, h);
 159             }
 160         }
 161     }
 162
 163     public void Dispose()
 164     {
 165         Dispose(true);
 166         GC.SuppressFinalize(this);
 167     }
 168
 169     public void Free()
 170     {
 171         Dispose();
 172     }
 173
 174     public IntPtr Release()
 175     {
 176         IntPtr h = Handle;
 177         Handle = IntPtr.Zero;
 178         return h;
 179     }
 180
 181     private void FreeElementsIfOwned()
 182     {
 183         if (OwnContent)
 184         {
 185             int len = Length;
 186             for (int i = 0; i < len; ++i)
 187             {
 188                 NativeFree<T>(InternalDataGet(i));
 189             }
 190         }
 191     }
 192
 193     public void Clean()
 194     {
 195         FreeElementsIfOwned();
 196         eina_array_clean_custom_export_mono(Handle);
 197     }
 198
 199     public void Flush()
 200     {
 201         FreeElementsIfOwned();
 202         eina_array_flush(Handle);
 203     }
 204
 205     public int Count()
 206     {
 207         return (int)eina_array_count_custom_export_mono(Handle);
 208     }
 209
 210     public void SetOwnership(bool ownAll)
 211     {
 212         Own = ownAll;
 213         OwnContent = ownAll;
 214     }
 215
 216     public void SetOwnership(bool own, bool ownContent)
 217     {
 218         Own = own;
 219         OwnContent = ownContent;
 220     }
 221
 222     public bool Push(T val)
 223     {
 224         IntPtr ele = ManagedToNativeAlloc(val);
 225         var r = InternalPush(ele);
 226         if (!r)
 227         {
 228             NativeFree<T>(ele);
 229         }
 230
 231         return r;
 232     }
 233
 234 // TODO ???
 235 //     public void Add(T val)
 236 //     {
 237 //         if (!Push(val))
 238 //         {
 239 //             throw;
 240 //         }
 241 //     }
 242
 243     public T Pop()
 244     {
 245         IntPtr ele = InternalPop();
 246         var r = NativeToManaged<T>(ele);
 247         if (OwnContent && ele != IntPtr.Zero)
 248         {
 249             NativeFree<T>(ele);
 250         }
 251
 252         return r;
 253     }
 254
 255     public T DataGet(int idx)
 256     {
 257         IntPtr ele = InternalDataGet(idx);
 258         return NativeToManaged<T>(ele);
 259     }
 260
 261     public T At(int idx)
 262     {
 263         return DataGet(idx);
 264     }
 265
 266     public void DataSet(int idx, T val)
 267     {
 268         IntPtr ele = InternalDataGet(idx); // TODO: check bondaries ??
 269         if (OwnContent && ele != IntPtr.Zero)
 270         {
 271             NativeFree<T>(ele);
 272         }
 273
 274         ele = ManagedToNativeAlloc(val);
 275         InternalDataSet(idx, ele);
 276     }
 277
 278     public T this[int idx]
 279     {
 280         get
 281         {
 282             return DataGet(idx);
 283         }
 284         set
 285         {
 286             DataSet(idx, value);
 287         }
 288     }
 289
 290     public T[] ToArray()
 291     {
 292         int len = Length;
 293         var managed = new T[len];
 294         for (int i = 0; i < len; ++i)
 295         {
 296             managed[i] = DataGet(i);
 297         }
 298
 299         return managed;
 300     }
 301
 302     public bool Append(T[] values)
 303     {
 304         foreach (T v in values)
 305         {
 306             if (!Push(v))
 307             {
 308                 return false;
 309             }
 310         }
 311
 312         return true;
 313     }
 314
 315
 316     public Eina.Iterator<T> GetIterator()
 317     {
 318         return new Eina.Iterator<T>(eina_array_iterator_new(Handle), true);
 319     }
 320
 321     public IEnumerator<T> GetEnumerator()
 322     {
 323         int len = Length;
 324         for (int i = 0; i < len; ++i)
 325         {
 326             yield return DataGet(i);
 327         }
 328     }
 329
 330     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 331     {
 332         return this.GetEnumerator();
 333     }
 334
 335     /// <summary> Gets an Accessor for this Array.</summary>
 336     public Eina.Accessor<T> GetAccessor()
 337     {
 338         return new Eina.Accessor<T>(eina_array_accessor_new(Handle), Ownership.Managed);
 339     }
 340 }
 341
 342 }