checkpoint

Alpm.Tests/Alpm.Tests.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp3.1</TargetFramework>
+
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+        <PackageReference Include="xunit" Version="2.4.0" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+        <PackageReference Include="coverlet.collector" Version="1.2.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Alpm\Alpm.csproj" />
+    </ItemGroup>
+
+</Project>

Alpm.Tests/AlpmIntegrationTest.cs

@@ -13,7 +13,7 @@ namespace Alpm.Tests
         public void TestLocalDB()
         {
             using var localDB = _handle.LocalDB;
-            Assert.Equal(15, localDB.PackageCache.Count());
+            Assert.True(localDB.CachePackageCache.Count() > 15);
         }
         
         [Fact]

Alpm/Backup.cs

@@ -1,8 +1,25 @@
+using System;
+using System.Runtime.InteropServices;
+
 namespace Foodsoft.Alpm
 {
     public struct Backup
     {
-        private string _name;
+        public string Name { get; }
-        private string _hash;
+        public string Hash { get; }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private readonly unsafe struct NativeBackup
+        {
+            internal readonly sbyte* name;
+            internal readonly sbyte* hash;
+        }
+
+        internal unsafe Backup(IntPtr ptr)
+        {
+            var native = (NativeBackup*) ptr;
+            Name = new string(native->name);
+            Hash = new string(native->hash);
+        }
     }
 }

Alpm/CachePackageList.cs

@@ -2,17 +2,16 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 
 namespace Foodsoft.Alpm
 {
-    public class PackageList : ICollection<CachePackage>
+    public class CachePackageList : IPackageList<CachePackage>, ICollection<CachePackage>
     {
         private readonly SafeDatabaseHandle _parentHandle;
         private readonly IntPtr _listPtr;
         private readonly Database _db;
 
-        internal PackageList(IntPtr listPtr, SafeDatabaseHandle parentHandle, Database db)
+        internal CachePackageList(IntPtr listPtr, SafeDatabaseHandle parentHandle, Database db)
         {
             _parentHandle = parentHandle;
             _listPtr = listPtr;
@@ -45,6 +44,7 @@ namespace Foodsoft.Alpm
         {
             return GetEnumerator();
         }
+
         public bool Contains(CachePackage item)
         {
             var name = item.Name;
@@ -63,16 +63,27 @@ namespace Foodsoft.Alpm
 
         public void CopyTo(CachePackage[] array, int arrayIndex)
         {
-            _parentHandle.UseHandle(_listPtr,(list) =>
+            _parentHandle.UseHandle(_listPtr, (list) =>
             {
                 for (; list != IntPtr.Zero; list = Wrapper.ListNext(list))
                 {
                     array[arrayIndex++] = new CachePackage(
                         new SafeCachePackageHandle(Wrapper.ListData(list), _parentHandle), _db);
                 }
+
                 return 0;
             });
         }
+        public CachePackage? FindSatisfier(string depString)
+        {
+            return _parentHandle.UseHandle(_listPtr, (list) =>
+            {
+                var pkgPtr = alpm.alpm_find_satisfier(list, depString);
+                return pkgPtr != IntPtr.Zero
+                    ? new CachePackage(new SafeCachePackageHandle(pkgPtr, _parentHandle), _db)
+                    : null;
+            });
+        }
 
         public void Add(CachePackage item)
         {
@@ -83,12 +94,13 @@ namespace Foodsoft.Alpm
         {
             throw new NotSupportedException();
         }
+
         public void Clear()
         {
             throw new NotSupportedException();
         }
 
-        public int Count => _parentHandle.UseHandle(_listPtr,(list) => (int) alpm.alpm_list_count(list));
+        public int Count => _parentHandle.UseHandle(_listPtr, (list) => (int) alpm.alpm_list_count(list));
 
         public bool IsReadOnly => true;
     }

Alpm/Database.cs

@@ -19,20 +19,11 @@ namespace Foodsoft.Alpm
         public bool RemoveServer(string url) =>
             API.WrapErrorBool(_handle.SafeAlpmHandle, () => alpm.alpm_db_remove_server(_handle, url));
 
-        private readonly struct ServersImpl : ICollectionImpl<string>
-        {
-            private readonly SafeDatabaseHandle _handle;
-            internal ServersImpl(SafeDatabaseHandle handle) => _handle = handle;
-            public SafeHandle Handle => _handle;
-            public IntPtr GetItems() => alpm.alpm_db_get_servers(_handle);
-            public string PtrToItem(IntPtr p) => Marshal.PtrToStringUTF8(p)!;
-        }
-
         // FIXME: This is "bug correct", but probably dumb to do it this way, instead just call add_server
         // like all the stuff in handle.
         public IEnumerable<string> Servers
         {
-            get => EnumerableWrapper<string>.Create(new ServersImpl(_handle));
+            get => EnumerableWrapper.Create(_handle, alpm.alpm_db_get_servers);
             set
             {
                 var listPtr = IntPtr.Zero;
@@ -94,14 +85,14 @@ namespace Foodsoft.Alpm
             return new CachePackage(new SafeCachePackageHandle(pkgPtr, _handle), this);
         }
 
-        public PackageList PackageCache
+        public CachePackageList CachePackageCache
         {
             get
             {
                 var listPtr = alpm.alpm_db_get_pkgcache(_handle);
                 if (listPtr == IntPtr.Zero)
                     throw new AlpmException(_handle.SafeAlpmHandle);
-                return new PackageList(listPtr, _handle, this);
+                return new CachePackageList(listPtr, _handle, this);
             }
         }
 

Alpm/Depend.cs

@@ -1,12 +1,9 @@
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 
 namespace Foodsoft.Alpm
 {
-
-    
-    [StructLayout(LayoutKind.Sequential)]
-    [SuppressMessage("ReSharper", "ConvertToConstant.Local")]
     public class Depend
     {
         public enum ModType
@@ -19,16 +16,31 @@ namespace Foodsoft.Alpm
             LessThan
         }
         
-        [field: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public string Name { get; }
-        public string Name { get; } = null!;
+        public string Version { get; }
+        public string Description { get; }
+        public ulong NameHash { get; }
+        public ModType Mod { get; }
 
-        [field: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [StructLayout(LayoutKind.Sequential)]
-        public string Version { get; } = null!;
+        private readonly unsafe struct NativeDepend
+        {
+            internal readonly sbyte* name;
+            internal readonly sbyte* version;
+            internal readonly sbyte* description;
+            internal readonly ulong name_hash;
+            internal readonly Depend.ModType mod;
+        }
 
-        [field: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        internal unsafe Depend(IntPtr ptr)
-        public string Description { get; } = null!;
+        {
+            var native = (NativeDepend*) ptr;
+            Name = new string(native->name);
+            Version = new string(native->version);
+            Description = new string(native->description);
+            NameHash = native->name_hash;
+            Mod = native->mod;
+        }
         
-        public ulong NameHash { get; } = 0;
-        public ModType Mod { get; } = ModType.Any;
     }
 }

Alpm/EnumerableWrapper.cs

@@ -7,23 +7,34 @@ using System.Runtime.InteropServices;
 
 namespace Foodsoft.Alpm
 {
-    internal static class EnumerableWrapperEx<TElement>
+    internal static class EnumerableWrapper
     {
-        internal static EnumerableWrapperEx<TElement, THandle> Create<THandle>(THandle handle,
+        internal static EnumerableWrapper<string, THandle> Create<THandle>(THandle handle,
-            Func<THandle, IntPtr> getItems,
+            Func<THandle, IntPtr> getItems) where THandle : SafeHandle
-            Func<IntPtr, TElement> getElement) where THandle : SafeHandle
         {
-            return new EnumerableWrapperEx<TElement, THandle>(handle, getItems, getElement);
+            return new EnumerableWrapper<string, THandle>(handle, getItems, Marshal.PtrToStringUTF8!);
+        }
+        
+        internal static EnumerableWrapper<Depend, THandle> CreateForDepend<THandle>(THandle handle,
+            Func<THandle, IntPtr> getItems) where THandle : SafeHandle
+        {
+            return new EnumerableWrapper<Depend, THandle>(handle, getItems, (ptr) => new Depend(ptr));
+        }
+        
+        internal static EnumerableWrapper<Backup, THandle> CreateForBackup<THandle>(THandle handle,
+            Func<THandle, IntPtr> getItems) where THandle : SafeHandle
+        {
+            return new EnumerableWrapper<Backup, THandle>(handle, getItems, (ptr) => new Backup(ptr));
         }
     }
 
-    internal readonly struct EnumerableWrapperEx<TElement, THandle> : ICollection<TElement> where THandle : SafeHandle
+    internal readonly struct EnumerableWrapper<TElement, THandle> : ICollection<TElement> where THandle : SafeHandle
     {
         private readonly THandle _handle;
         private readonly Func<THandle, IntPtr> _getItems;
         private readonly Func<IntPtr, TElement> _getElement;
 
-        internal EnumerableWrapperEx(THandle handle, Func<THandle, IntPtr> getItems, Func<IntPtr, TElement> getElement)
+        internal EnumerableWrapper(THandle handle, Func<THandle, IntPtr> getItems, Func<IntPtr, TElement> getElement)
         {
             _handle = handle;
             _getItems = getItems;

Alpm/EnumerableWrapper`3.cs

@@ -1,120 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Dynamic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace Foodsoft.Alpm
-{
-    internal static class EnumerableWrapper<TElement>
-    {
-        internal static EnumerableWrapper<TElement, TImpl> Create<TImpl>(TImpl impl)
-            where TImpl : struct, ICollectionImpl<TElement>
-        {
-            return new EnumerableWrapper<TElement, TImpl>(impl);
-        }
-    }
-
-    internal struct EnumerableWrapper<TElement, TImpl> : ICollection<TElement> where TImpl : struct,
-        ICollectionImpl<TElement>
-    {
-        private TImpl _impl;
-
-        public static EnumerableWrapper<TElement, TImpl> Create(TImpl impl)
-        {
-            return new EnumerableWrapper<TElement, TImpl>(impl);
-        }
-
-        public EnumerableWrapper(TImpl impl)
-        {
-            _impl = impl;
-        }
-
-        public IEnumerator<TElement> GetEnumerator()
-        {
-            var handle = _impl.Handle;
-            var release = false;
-
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                handle.DangerousAddRef(ref release);
-                if (!release) throw new ObjectDisposedException(_impl.GetType().FullName);
-                for (var list = _impl.GetItems(); list != IntPtr.Zero; list = Wrapper.ListNext(list))
-                {
-                    yield return _impl.PtrToItem(Wrapper.ListData(list));
-                }
-            }
-            finally
-            {
-                if (release)
-                    handle.DangerousRelease();
-            }
-        }
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
-        public int Count
-        {
-            get
-            {
-                var impl = _impl;
-                return impl.Handle.UseHandle((_) => (int) alpm.alpm_list_count(impl.GetItems()));
-            }
-        }
-
-        public bool Contains(TElement item)
-        {
-            var impl = _impl;
-            switch (item)
-            {
-                case string s:
-                    return impl.Handle.UseHandle((_) => alpm.alpm_list_find_str(impl.GetItems(), s) != (IntPtr.Zero));
-                default:
-                    var comparer = EqualityComparer<TElement>.Default;
-                    return _impl.Handle.UseHandle((_) =>
-                    {
-                        for (var list = impl.GetItems(); list != IntPtr.Zero; list = Wrapper.ListNext(list))
-                        {
-                            if (comparer.Equals(item, impl.PtrToItem(Wrapper.ListData(list))))
-                                return true;
-                        }
-
-                        return false;
-                    });
-            }
-        }
-
-        public void CopyTo(TElement[] array, int arrayIndex)
-        {
-            var impl = _impl;
-            impl.Handle.UseHandle((_) =>
-            {
-                for (var list = impl.GetItems(); list != IntPtr.Zero; list = Wrapper.ListNext(list))
-                {
-                    array[arrayIndex++] = impl.PtrToItem(Wrapper.ListData(list));
-                }
-
-                return arrayIndex;
-            });
-        }
-
-        public void Add(TElement item)
-        {
-            throw new NotSupportedException();
-        }
-
-        public void Clear()
-        {
-            throw new NotSupportedException();
-        }
-
-        public bool Remove(TElement item)
-        {
-            throw new NotSupportedException();
-        }
-
-        public bool IsReadOnly => true;
-    }
-}

Alpm/File.cs

@@ -1,15 +1,32 @@
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
+using Foodsoft.Alpm.Marshalling;
 
 namespace Foodsoft.Alpm
 {
-    [SuppressMessage("ReSharper", "UnassignedGetOnlyAutoProperty")]
     public readonly struct File
     {
-        [field: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
         public string Name { get; }
 
         public long Size { get; }
         public uint Mode { get; }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal readonly unsafe struct NativeFile
+        {
+            internal readonly sbyte* Name;
+            internal readonly long size;
+            internal readonly uint mode;
+        }
+
+        internal unsafe File(IntPtr ptr)
+        {
+            var native = (NativeFile*) ptr;
+            Name = new string(native->Name);
+            Size = native->size;
+            Mode = native->mode;
+        }
     }
+
 }

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

Alpm/Handle.cs

@@ -41,20 +41,10 @@ namespace Foodsoft.Alpm
         
         public void AddCacheDir(string dir) => API.WrapError(_handle, () => alpm.alpm_option_add_cachedir(_handle, dir));
         public bool RemoveCacheDir(string dir) => API.WrapErrorBool(_handle, () => alpm.alpm_option_add_cachedir(_handle, dir));
-
-        private readonly struct CacheDirsImpl : ICollectionImpl<string>
-        {
-            private readonly SafeAlpmHandle _handle;
-            internal CacheDirsImpl(SafeAlpmHandle handle) => _handle = handle;
-            public SafeHandle Handle => _handle;
-            public IntPtr GetItems() => alpm.alpm_option_get_cachedirs(_handle);
-            public string PtrToItem(IntPtr p) => Marshal.PtrToStringUTF8(p)!;
-        }
-        
         public ICollection<string> CacheDirs
         {
             get =>
-                EnumerableWrapperEx<string>.Create(_handle, alpm.alpm_option_get_cachedirs, Marshal.PtrToStringUTF8!);
+                EnumerableWrapper.Create(_handle, alpm.alpm_option_get_cachedirs);
             set => Wrapper.SetStringCollection(value, _handle, (s) => alpm.alpm_option_add_cachedir(_handle, s));
         }
 

Alpm/IItemsReader`2.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace Foodsoft.Alpm
-{
-    internal interface ICollectionImpl<TElement>
-    {
-        public SafeHandle Handle { get; }
-        public IntPtr GetItems();
-        public TElement PtrToItem(IntPtr p);
-    }
-}

Alpm/IPackageData.cs

@@ -53,8 +53,8 @@ namespace Foodsoft.Alpm
         public ICollection<Depend> Conflicts { get; }
         public ICollection<Depend> Provides { get; }
         public ICollection<Depend> Replaces { get; }
-        public IReadOnlyList<File> FileList { get; }
+        public IReadOnlyList<File> Files { get; }
-        public IReadOnlyList<Backup> Backup { get; }
+        public ICollection<Backup> Backup { get; }
         public string Base64Signature { get; }
         public ValidationType Validation { get; }
         public bool HasScriptlet { get; }

Alpm/IPackageList.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Foodsoft.Alpm
+{
+    public interface IPackageList<out T> : IEnumerable<T> where T : Package
+    {
+        public T? FindSatisfier(string depString);
+    }
+}

Alpm/Marshalling/UTF8In.cs

@@ -1,12 +1,11 @@
 using System;
 using System.Runtime.InteropServices;
-using System.Text;
 
-namespace Foodsoft.Alpm
+namespace Foodsoft.Alpm.Marshalling
 {
-    internal readonly struct UTF8InMarshaler : ICustomMarshaler
+    internal readonly struct UTF8In : ICustomMarshaler
     {
-        private static readonly UTF8InMarshaler _instance = default;
+        private static readonly UTF8In _instance = default;
 
         public void CleanUpManagedData(object managedObj) { }
 

Alpm/Marshalling/UTF8Return.cs

@@ -1,13 +1,11 @@
-namespace Foodsoft.Alpm
+using System;
+using System.Runtime.InteropServices;
+
+namespace Foodsoft.Alpm.Marshalling
 {
-    using System;
+    internal readonly struct UTF8Return : ICustomMarshaler
-    using System.Runtime.InteropServices;
-    using System.Text;
-
-
-    internal readonly struct UTF8OutMarshaler : ICustomMarshaler
     {
-        private static readonly UTF8OutMarshaler _instance = default;
+        private static readonly UTF8Return _instance = default;
 
         // ReSharper disable once UnusedMember.Local
         // ReSharper disable once UnusedParameter.Local

Alpm/Package.cs

@@ -30,24 +30,25 @@ namespace Foodsoft.Alpm
         public long Size => alpm.alpm_pkg_get_size(Handle);
         public long InstalledSize => alpm.alpm_pkg_get_isize(Handle);
         public InstallReason InstallReason => alpm.alpm_pkg_get_reason(Handle);
-
         public ICollection<string> Licenses =>
-            EnumerableWrapperEx<string>.Create(Handle, alpm.alpm_pkg_get_licenses, Marshal.PtrToStringUTF8!);
+            EnumerableWrapper.Create(Handle, alpm.alpm_pkg_get_licenses);
-
+        public ICollection<string> Groups => EnumerableWrapper.Create(Handle, alpm.alpm_pkg_get_groups);
-        public ICollection<string> Groups { get; }
+        public ICollection<Depend> Depends => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_depends);
-        public ICollection<Depend> Depends { get; }
+        public ICollection<Depend> OptDepends =>
-        public ICollection<Depend> OptDepends { get; }
+            EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_optdepends);
-        public ICollection<Depend> CheckDepends { get; }
+        public ICollection<Depend> CheckDepends =>
-        public ICollection<Depend> MakeDepends { get; }
+            EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_checkdepends);
-        public ICollection<Depend> Conflicts { get; }
+        public ICollection<Depend> MakeDepends =>
-        public ICollection<Depend> Provides { get; }
+            EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_makedepends);
-        public ICollection<Depend> Replaces { get; }
+        public ICollection<Depend> Conflicts => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_conflicts);
-        public IReadOnlyList<File> FileList { get; }
+        public ICollection<Depend> Provides => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_provides);
-        public IReadOnlyList<Backup> Backup { get; }
+        public ICollection<Depend> Replaces => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_replaces);
-        public string Base64Signature { get; }
+        public IReadOnlyList<File> Files => new FileList(Handle, alpm.alpm_pkg_get_files(Handle));
-        public ValidationType Validation { get; }
+        public ICollection<Backup> Backup => EnumerableWrapper.CreateForBackup(Handle, alpm.alpm_pkg_get_backup);
-        public bool HasScriptlet { get; }
+        public string Base64Signature => alpm.alpm_pkg_get_base64_sig(Handle);
-        public long DownloadSize { get; }
+        public ValidationType Validation => alpm.alpm_pkg_get_validation(Handle);
+        public bool HasScriptlet => alpm.alpm_pkg_has_scriptlet(Handle);
+        public long DownloadSize => alpm.alpm_pkg_download_size(Handle);
 
         public bool CheckMD5Sum()
         {

Alpm/Wrapper.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 

Alpm/alpm.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.WindowsRuntime;
+using Foodsoft.Alpm.Marshalling;
-using Foodsoft.Alpm;
 
 namespace Foodsoft.Alpm
 {
@@ -11,7 +9,7 @@ namespace Foodsoft.Alpm
     internal struct alpm_list_t
     {
         internal IntPtr data;
-        internal readonly IntPtr prev;
+        private readonly IntPtr prev;
         internal readonly IntPtr next;
     }
 
@@ -22,34 +20,34 @@ namespace Foodsoft.Alpm
         public static extern int alpm_pkg_should_ignore(SafeAlpmHandle handle, SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_filename(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_base(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_name(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_name(IntPtr pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_version(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
         public static extern PackageOrigin alpm_pkg_get_origin(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_desc(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_url(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
@@ -59,19 +57,19 @@ namespace Foodsoft.Alpm
         public static extern long alpm_pkg_get_installdate(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_packager(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_md5sum(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_sha256sum(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_pkg_get_arch(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
@@ -87,32 +85,52 @@ namespace Foodsoft.Alpm
         public static extern IntPtr alpm_pkg_get_licenses(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_groups(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_groups(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_depends(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_depends(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_optdepends(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_optdepends(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_checkdepends(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_checkdepends(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_makedepends(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_makedepends(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_conflicts(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_conflicts(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        public static extern IntPtr alpm_pkg_get_provides(SafePackageHandle pkg);
-        public static extern string alpm_pkg_get_provides(SafePackageHandle pkg);
+
+        [DllImport(nameof(alpm))]
+        public static extern IntPtr alpm_pkg_get_replaces(SafePackageHandle pkg);
+
+        [DllImport(nameof(alpm))]
+        public static extern IntPtr alpm_pkg_get_files(SafePackageHandle pkg);
+
+        [DllImport(nameof(alpm))]
+        public static extern IntPtr alpm_pkg_get_backup(SafePackageHandle pkg);
+
+        [DllImport(nameof(alpm))]
+        public static extern IntPtr alpm_filelist_contains(IntPtr fileList,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
+            string path);
+
+        [DllImport(nameof(alpm))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
+        public static extern string alpm_pkg_get_base64_sig(SafePackageHandle pkg);
+        
+        [DllImport(nameof(alpm))]
+        public static extern ValidationType alpm_pkg_get_validation(SafePackageHandle pkg);
+
+        [DllImport(nameof(alpm))]
+        public static extern bool alpm_pkg_has_scriptlet(SafePackageHandle pkg);
+
+        [DllImport(nameof(alpm))]
+        public static extern long alpm_pkg_download_size(SafePackageHandle pkg);
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_pkg_set_reason(SafePackageHandle pkg, InstallReason reason);
@@ -123,24 +141,21 @@ namespace Foodsoft.Alpm
         [DllImport(nameof(alpm))]
         public static extern IntPtr alpm_option_get_cachedirs(SafeAlpmHandle handle);
         
-        [DllImport(nameof(alpm))]
-        public static extern int alpm_option_set_cachedirs(SafeAlpmHandle handle, IntPtr cachedirs);
-
         [DllImport(nameof(alpm))]
         public static extern int alpm_option_add_cachedir(SafeAlpmHandle handle,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string cachedir);
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_option_remove_cachedir(SafeAlpmHandle handle,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string cachedir);
 
         [DllImport(nameof(alpm))]
         public static extern ErrNo alpm_errno(SafeAlpmHandle handle);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_strerror(ErrNo err);
 
         [DllImport(nameof(alpm))]
@@ -151,7 +166,7 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern IntPtr alpm_register_syncdb(SafeAlpmHandle handle,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string treename, SigLevel sigLevel);
 
         [DllImport(nameof(alpm))]
@@ -162,7 +177,7 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern IntPtr alpm_list_append_strdup(ref IntPtr list,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string str);
 
         [DllImport(nameof(alpm))]
@@ -182,14 +197,14 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern IntPtr alpm_list_find_str(IntPtr list,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string needle);
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_unlock(Handle handle);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_version();
 
         [DllImport(nameof(alpm))]
@@ -197,8 +212,8 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern SafeAlpmHandle alpm_initialize(
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
-            string root, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            string root, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string dbpath, out ErrNo err);
 
         [DllImport(nameof(alpm))]
@@ -206,14 +221,14 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_db_remove_server(SafeDatabaseHandle db,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string url);
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_db_unregister(IntPtr db);
 
         [DllImport(nameof(alpm))]
-        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Return))]
         public static extern string alpm_db_get_name(SafeDatabaseHandle db);
 
         [DllImport(nameof(alpm))]
@@ -233,12 +248,12 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_db_add_server(SafeDatabaseHandle db,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string url);
 
         [DllImport(nameof(alpm))]
         public static extern IntPtr alpm_pkg_get_pkg(SafeDatabaseHandle db,
-            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
             string name);
 
         [DllImport(nameof(alpm))]
@@ -246,5 +261,8 @@ namespace Foodsoft.Alpm
 
         [DllImport(nameof(alpm))]
         public static extern int alpm_pkg_vercmp(string v1, string v2);
+        
+        [DllImport(nameof(alpm))]
+        public static extern IntPtr alpm_find_satisfier(IntPtr pkgList, string depstring);
     }
 }

DotNetAlpm.sln.DotSettings

@@ -1,7 +1,10 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=alpm/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=depstring/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Foodsoft/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Marshaler/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=pacman/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=satisfier/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=strdup/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=syncdb/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=syncdbs/@EntryIndexedValue">True</s:Boolean>

Samples/Program.cs

@@ -12,15 +12,37 @@ namespace Samples
     [Example("installed")]
     internal class Installed : IExample
     {
+        private static string ModToStr(Depend.ModType modType)
+        {
+            return modType switch
+            {
+                Depend.ModType.Any => "",
+                Depend.ModType.Equal => "==",
+                Depend.ModType.GreaterThanOrEqual => ">=",
+                Depend.ModType.LessThanOrEqual => "<=",
+                Depend.ModType.GreaterThan => ">",
+                Depend.ModType.LessThan => "<",
+                _ => throw new ArgumentOutOfRangeException(nameof(modType), modType, null)
+            };
+        }
+
         public int Run(string[] args)
         {
             using var h = new Handle("/", "/var/lib/pacman");
             using var db = h.LocalDB;
 
-            foreach (var pkg in db.PackageCache)
+            foreach (var pkg in db.CachePackageCache)
                 using (pkg)
                 {
-                    Console.WriteLine("{0} {1}", pkg.Name, pkg.Version);
+                    Console.WriteLine($"Size: {pkg.DownloadSize}");
+                    foreach (var d in pkg.OptDepends)
+                    {
+                        if (d.Description.Length == 0) continue;
+                        Console.WriteLine("dep({0}): {1} {2} {3} {4}", pkg.Name, d.Name, ModToStr(d.Mod), d.Version,
+                            d.Description);
+                        foreach (var f in pkg.Backup)
+                            Console.WriteLine($"{f.Name} {f.Hash}");
+                    }
                 }
 
             return 0;
@@ -34,10 +56,10 @@ namespace Samples
         {
             using var h = new Handle("/", "/var/lib/pacman");
             using var db = h.RegisterSyncDB("core");
-            db.Servers = new[]{"http://www.google.com"};
+            db.Servers = new[] {"http://www.google.com"};
             db.Update(true);
 
-            foreach (var pkg in db.PackageCache)
+            foreach (var pkg in db.CachePackageCache)
                 using (pkg)
                 {
                     Console.WriteLine("{0} {1} {2}", pkg.Name, pkg.Version, pkg.Description);