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);
}
}
}