checkpoint

Alpm/FileList.cs

@@ -1,14 +1,50 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace Foodsoft.Alpm
 {
-    public class FileList : IReadOnlyList<File>
+    public struct FileList : IReadOnlyList<File>
     {
-        
+        private readonly SafePackageHandle _handle;
+        private readonly IntPtr _ptr;
+
+        internal FileList(SafePackageHandle handle, IntPtr ptr)
+        {
+            _handle = handle;
+            _ptr = ptr;
+        }
+
+        public File? Contains(string path)
+        {
+            return _handle.UseHandle(_ptr, (ptr) =>
+            {
+                var foundPtr = alpm.alpm_filelist_contains(ptr, path);
+                return foundPtr != IntPtr.Zero ? new File(foundPtr) : (File?) null;
+            });
+        }
         public IEnumerator<File> GetEnumerator()
         {
-            throw new System.NotImplementedException();
+            var release = false;
+
+            RuntimeHelpers.PrepareConstrainedRegions();
+            try
+            {
+                _handle.DangerousAddRef(ref release);
+                if (!release) throw new ObjectDisposedException(_handle.GetType().FullName);
+                var arrayPtr = FileArray(_ptr, out var count);
+                for (var i = 0; i < count; ++i)
+                {
+                    yield return new File(FilePtr(arrayPtr, i));
+                }
+            }
+            finally
+            {
+                if (release)
+                    _handle.DangerousRelease();
+            }
         }
 
         IEnumerator IEnumerable.GetEnumerator()
@@ -16,8 +52,46 @@ namespace Foodsoft.Alpm
             return GetEnumerator();
         }
 
-        public int Count { get; }
+        public int Count => _handle.UseHandle(_ptr, FileCount);
 
-        public File this[int index] => throw new System.NotImplementedException();
+        public File this[int index]
+        {
+            get
+            {
+                return _handle.UseHandle(_ptr, (ptr) =>
+                {
+                    var arrayPtr = FileArray(ptr, out var count);
+                    if (index >= count || index < 0)
+                        throw new ArgumentOutOfRangeException(nameof(index), index, $"Exceeds size {count}");
+                    return new File(FilePtr(arrayPtr, index));
+                });
+            }
+        }
+        
+        
+        [StructLayout(LayoutKind.Sequential)]
+        private readonly unsafe struct NativeFileList
+        {
+            internal readonly UIntPtr count;
+            internal readonly File.NativeFile* files;
+        }
+
+        private static unsafe IntPtr FilePtr(IntPtr array, int i)
+        {
+            return (IntPtr) ((File.NativeFile*) array + i);
+        }
+
+        private static unsafe IntPtr FileArray(IntPtr ptr, out int count)
+        {
+            var list = (NativeFileList*) ptr;
+            count = (int) list->count;
+            return (IntPtr) list->files;
+        }
+
+        private static unsafe int FileCount(IntPtr ptr)
+        {
+            var list = (NativeFileList*) ptr;
+            return (int) list->count;
+        }
     }
 }