jkl1337/DotNetAlpm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

checkpoint

Browse Source
This commit is contained in:
John K. Luebs
2020-04-30 13:33:30 -04:00
parent 19a9fc06ba
commit 9bc522180d
21 changed files with 337 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
Alpm/Backup.cs
View File

@@ -1,8 +1,25 @@
using System;
using System.Runtime.InteropServices;
namespace Foodsoft.Alpm
{
public struct Backup
{
private string _name;
private string _hash;
public string Name { get; }
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);
}
}
}

26
Alpm/PackageList.cs → Alpm/CachePackageList.cs
View File

@@ -2,27 +2,26 @@ 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;
_db = db;
}
public IEnumerator<CachePackage> GetEnumerator()
{
var release = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
@@ -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;
}

15
Alpm/Database.cs
View File

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

38
Alpm/Depend.cs
View File

@@ -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; } = null!;
public string Name { get; }
public string Version { get; }
public string Description { get; }
public ulong NameHash { get; }
public ModType Mod { get; }
[field: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public string Version { get; } = null!;
[StructLayout(LayoutKind.Sequential)]
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))]
public string Description { get; } = null!;
public ulong NameHash { get; } = 0;
public ModType Mod { get; } = ModType.Any;
internal unsafe Depend(IntPtr ptr)
{
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;
}
}
}

25
Alpm/EnumerableWrapperEx.cs → Alpm/EnumerableWrapper.cs
View File

@@ -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,
Func<THandle, IntPtr> getItems,
Func<IntPtr, TElement> getElement) where THandle : SafeHandle
internal static EnumerableWrapper<string, THandle> Create<THandle>(THandle handle,
Func<THandle, IntPtr> getItems) 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;

120
Alpm/EnumerableWrapper`3.cs
View File

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

21
Alpm/File.cs
View File

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

84
Alpm/FileList.cs
View File

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

12
Alpm/Handle.cs
View File

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

12
Alpm/IItemsReader`2.cs
View File

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

4
Alpm/IPackageData.cs
View File

@@ -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<Backup> Backup { get; }
public IReadOnlyList<File> Files { get; }
public ICollection<Backup> Backup { get; }
public string Base64Signature { get; }
public ValidationType Validation { get; }
public bool HasScriptlet { get; }

9
Alpm/IPackageList.cs Normal file
View File

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

7
Alpm/UTF8InMarshaler.cs → Alpm/Marshalling/UTF8In.cs
View File

@@ -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) { }

14
Alpm/UTF8OutMarshaler.cs → Alpm/Marshalling/UTF8Return.cs
View File

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

35
Alpm/Package.cs
View File

@@ -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!);
public ICollection<string> Groups { get; }
public ICollection<Depend> Depends { get; }
public ICollection<Depend> OptDepends { get; }
public ICollection<Depend> CheckDepends { get; }
public ICollection<Depend> MakeDepends { get; }
public ICollection<Depend> Conflicts { get; }
public ICollection<Depend> Provides { get; }
public ICollection<Depend> Replaces { get; }
public IReadOnlyList<File> FileList { get; }
public IReadOnlyList<Backup> Backup { get; }
public string Base64Signature { get; }
public ValidationType Validation { get; }
public bool HasScriptlet { get; }
public long DownloadSize { get; }
EnumerableWrapper.Create(Handle, alpm.alpm_pkg_get_licenses);
public ICollection<string> Groups => EnumerableWrapper.Create(Handle, alpm.alpm_pkg_get_groups);
public ICollection<Depend> Depends => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_depends);
public ICollection<Depend> OptDepends =>
EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_optdepends);
public ICollection<Depend> CheckDepends =>
EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_checkdepends);
public ICollection<Depend> MakeDepends =>
EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_makedepends);
public ICollection<Depend> Conflicts => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_conflicts);
public ICollection<Depend> Provides => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_provides);
public ICollection<Depend> Replaces => EnumerableWrapper.CreateForDepend(Handle, alpm.alpm_pkg_get_replaces);
public IReadOnlyList<File> Files => new FileList(Handle, alpm.alpm_pkg_get_files(Handle));
public ICollection<Backup> Backup => EnumerableWrapper.CreateForBackup(Handle, alpm.alpm_pkg_get_backup);
public string Base64Signature => alpm.alpm_pkg_get_base64_sig(Handle);
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()
{

1
Alpm/Wrapper.cs
View File

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

114
Alpm/alpm.cs
View File

@@ -1,8 +1,6 @@
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.WindowsRuntime;
using Foodsoft.Alpm;
using Foodsoft.Alpm.Marshalling;
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 string alpm_pkg_get_groups(SafePackageHandle pkg);
public static extern IntPtr alpm_pkg_get_groups(SafePackageHandle pkg);
[DllImport(nameof(alpm))]
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public static extern string alpm_pkg_get_depends(SafePackageHandle pkg);
public static extern IntPtr alpm_pkg_get_depends(SafePackageHandle pkg);
[DllImport(nameof(alpm))]
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public static extern string alpm_pkg_get_optdepends(SafePackageHandle pkg);
public static extern IntPtr alpm_pkg_get_optdepends(SafePackageHandle pkg);
[DllImport(nameof(alpm))]
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public static extern string alpm_pkg_get_checkdepends(SafePackageHandle pkg);
public static extern IntPtr alpm_pkg_get_checkdepends(SafePackageHandle pkg);
[DllImport(nameof(alpm))]
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public static extern string alpm_pkg_get_makedepends(SafePackageHandle pkg);
public static extern IntPtr alpm_pkg_get_makedepends(SafePackageHandle pkg);
[DllImport(nameof(alpm))]
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public static extern string alpm_pkg_get_conflicts(SafePackageHandle pkg);
public static extern IntPtr alpm_pkg_get_conflicts(SafePackageHandle pkg);
[DllImport(nameof(alpm))]
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8OutMarshaler))]
public static extern string alpm_pkg_get_provides(SafePackageHandle pkg);
public static extern IntPtr 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);
@@ -122,25 +140,22 @@ 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))]
string root, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8InMarshaler))]
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8In))]
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);
}
}