using System; using System.Collections; using System.Collections.Generic; using System.Runtime.InteropServices; using static Eina.TraitFunctions; using static Eina.AccessorNativeFunctions; namespace Eina { internal class AccessorNativeFunctions { [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool eina_accessor_data_get(IntPtr accessor, uint position, IntPtr data); [DllImport(efl.Libs.Eina)] public static extern void eina_accessor_free(IntPtr accessor); } /// Accessors provide an uniform way of accessing Eina containers, similar to C++ STL's and C# IEnumerable. public class Accessor : IEnumerable, IDisposable { /// Pointer to the native accessor. public IntPtr Handle { get; private set; } = IntPtr.Zero; /// Who is in charge of releasing the resources wrapped by this instance. private Ownership Ownership { get; set; } // FIXME Part of the implicit EFL Container interface. Need to make it explicit. ///Whether this wrapper owns the native accessor. public bool Own { get { return Ownership == Ownership.Managed; } set { Ownership = value ? Ownership.Managed : Ownership.Unmanaged; } } /// Create a new accessor wrapping the given pointer. /// The native handle to be wrapped. /// Whether this wrapper owns the native accessor. public Accessor(IntPtr handle, Ownership owner = Ownership.Managed) { Handle = handle; Ownership = owner; } /// Create a new accessor wrapping the given pointer. /// The native handle to be wrapped. /// Whether this wrapper owns the native accessor. /// For compatibility with other EFL# containers. Ignored in acessors. public Accessor(IntPtr handle, bool own, bool ownContent = false) : this(handle, own ? Ownership.Managed : Ownership.Unmanaged) { } /// Release the native resources held by this instance. public void Dispose() { Dispose(true); } /// Disposes of this wrapper, releasing the native accessor if owned. /// True if this was called from public method. False if /// called from the C# finalizer. protected virtual void Dispose(bool disposing) { if (Ownership == Ownership.Managed && Handle != IntPtr.Zero) { eina_accessor_free(Handle); Handle = IntPtr.Zero; } } /// Finalizer to be called from the Garbage Collector. ~Accessor() { Dispose(false); } /// Convert the native data into managed. This is used when returning the data through a /// . /// The data to be converted /// The managed data representing data. protected virtual T Convert(IntPtr data) { return NativeToManaged(data); } /// Returns an enumerator that iterates throught this accessor. /// An enumerator to walk through the acessor items. public IEnumerator GetEnumerator() { if (Handle == IntPtr.Zero) { throw new ObjectDisposedException(base.GetType().Name); } IntPtr tmp = MemoryNative.Alloc(Marshal.SizeOf(typeof(IntPtr))); uint position = 0; try { while (eina_accessor_data_get(Handle, position, tmp)) { IntPtr data = (IntPtr)Marshal.PtrToStructure(tmp, typeof(IntPtr)); yield return Convert(data); position += 1; } } finally { MemoryNative.Free(tmp); } } IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); } } ///Accessor for Inlists. public class AccessorInList : Accessor { /// Create a new accessor wrapping the given pointer. /// The native handle to be wrapped. /// Whether this wrapper owns the native accessor. public AccessorInList(IntPtr handle, Ownership own) : base(handle, own) { } /// Convert the native data into managed. This is used when returning the data through a /// . /// The data to be converted /// The managed data representing data. protected override T Convert(IntPtr data) { return NativeToManagedInlistNode(data); } } ///Accessor for Inarrays. public class AccessorInArray : Accessor { /// Create a new accessor wrapping the given pointer. /// The native handle to be wrapped. /// Whether this wrapper owns the native accessor. public AccessorInArray(IntPtr handle, Ownership own) : base(handle, own) { } /// Convert the native data into managed. This is used when returning the data through a /// . /// The data to be converted /// The managed data representing data. protected override T Convert(IntPtr data) { return NativeToManagedInplace(data); } } }