/// <summary>
/// Convert a GVariant handle that points to a list of lists of two strings into
/// a C# string array. The original strings in the inner lists are separated by
/// double semicolons in the output elements of the C# string array.
/// </summary>
/// <remarks>
/// No check is made to verify that the input value actually points to a list of
/// lists of two strings.
/// </remarks>
public static string[] GetStringArrayFromGVariantListArray(IntPtr value)
{
if (value == IntPtr.Zero)
{
return(new string[0]);
}
uint size = Unmanaged.g_variant_n_children(value);
string[] list = new string[size];
for (uint i = 0; i < size; ++i)
{
IntPtr duple = Unmanaged.g_variant_get_child_value(value, i);
var values = GetStringArrayFromGVariantArray(duple);
Debug.Assert(values.Length == 2);
list[i] = String.Format("{0};;{1}", values[0], values[1]);
Unmanaged.g_variant_unref(duple);
//Console.WriteLine("DEBUG GetStringArrayFromGVariantListArray(): list[{0}] = \"{1}\"", i, list[i]);
}
return(list);
}
/// <summary>
/// Convert a GVariant handle that points to a list of strings to a C# string array.
/// Without leaking memory in the process!
/// </summary>
/// <remarks>
/// No check is made to verify that the input value actually points to a list of strings.
/// </remarks>
public static string[] GetStringArrayFromGVariantArray(IntPtr value)
{
if (value == IntPtr.Zero)
{
return(new string[0]);
}
uint size = Unmanaged.g_variant_n_children(value);
string[] list = new string[size];
for (uint i = 0; i < size; ++i)
{
IntPtr child = Unmanaged.g_variant_get_child_value(value, i);
int length;
// handle must not be freed -- it points into the actual GVariant memory for child!
IntPtr handle = Unmanaged.g_variant_get_string(child, out length);
var rawbytes = new byte[length];
Marshal.Copy(handle, rawbytes, 0, length);
list[i] = Encoding.UTF8.GetString(rawbytes);
Unmanaged.g_variant_unref(child);
//Console.WriteLine("DEBUG GetStringArrayFromGVariant(): list[{0}] = \"{1}\" (length = {2})", i, list[i], length);
}
return(list);
}