private static object ObjectAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.AsObject());
}
}
private static DateTimeOffset DateTimeAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.DateTime ?? default(DateTimeOffset));
}
}
internal static SizeF SizeFAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.SizeF ?? default(SizeF));
}
}
private static int IntAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Int ?? default(int));
}
}
internal static Vector4 Vector4DAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Vector4D ?? default(Vector4));
}
}
private static long LongAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Long ?? default(long));
}
}
internal static RectangleF RectFAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.RectF ?? default(RectangleF));
}
}
internal static ulong ULongAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.ULong ?? default(long));
}
}
internal static double DoubleAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Double ?? default(double));
}
}
internal static float FloatAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Float ?? default(float));
}
}
internal static uint UIntAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.UInt ?? default(uint));
}
}
internal static char CharAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.Char ?? default(char));
}
}
internal static bool BoolAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant != null && variant.Bool);
}
}
internal static PointF PointFAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
return(variant?.PointF ?? default(PointF));
}
}
internal static float?FloatNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Float);
}
}
internal static RectangleF?RectFNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.RectF);
}
}
private static DateTimeOffset?DateTimeNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.DateTime);
}
}
private static string StringAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.String);
}
}
private static ulong?ULongNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.ULong);
}
}
private static double?DoubleNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Double);
}
}
internal static Matrix4x4?Matrix4x4NullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Matrix4x4);
}
}
internal static Quaternion?QuaternionNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Quaternion);
}
}
internal static Vector4?Vector4DNullableAt(NetVariantList list, int index)
{
using (var variant = list.Get(index))
{
if (variant == null || variant.VariantType == NetVariantType.Invalid)
{
return(null);
}
return(variant.Vector4D);
}
}
public void Can_add_variants()
{
using (var list = new NetVariantList())
{
using (var variant = new NetVariant())
{
variant.String = "test";
list.Add(variant);
list.Count.Should().Be(1);
list.Get(0).String.Should().Be("test");
}
}
}
public void Can_remove_variants()
{
using (var list = new NetVariantList())
{
using (var variant1 = new NetVariant())
using (var variant2 = new NetVariant())
{
variant1.String = "test1";
variant2.String = "test2";
list.Add(variant1);
list.Add(variant2);
list.Count.Should().Be(2);
list.Remove(0);
list.Count.Should().Be(1);
list.Get(0).String.Should().Be("test2");
}
}
}
public void InvokeMethod(IntPtr m, IntPtr t, IntPtr p, IntPtr r)
{
using (var method = new NetMethodInfo(m))
using (var target = new NetReference(t))
using (var parameters = new NetVariantList(p))
using (var result = r != IntPtr.Zero ? new NetVariant(r) : null)
{
var instance = target.Instance;
List <object> methodParameters = null;
if (parameters.Count > 0)
{
methodParameters = new List <object>();
var parameterCount = parameters.Count;
for (var x = 0; x < parameterCount; x++)
{
object v = null;
Helpers.Unpackvalue(ref v, parameters.Get(x));
methodParameters.Add(v);
}
}
MethodInfo methodInfo = null;
var methodName = method.MethodName;
var methods = instance.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(x => x.Name == methodName)
.ToList();
if (methods.Count == 1)
{
methodInfo = methods[0];
}
else if (methods.Count > 1)
{
// This is an overload.
// TODO: Make this more performant. https://github.com/pauldotknopf/Qml.Net/issues/39
// Get all the parameters for the method we are invoking.
var parameterTypes = method.GetAllParameters().Select(x => x.Type.FullTypeName).ToList();
// And find a good method to invoke.
foreach (var potentialMethod in methods)
{
var potentialMethodParameters = potentialMethod.GetParameters();
if (potentialMethodParameters.Length != parameterTypes.Count)
{
continue;
}
bool valid = true;
for (var x = 0; x < potentialMethodParameters.Length; x++)
{
if (potentialMethodParameters[x].ParameterType.AssemblyQualifiedName != parameterTypes[x])
{
valid = false;
break;
}
}
if (valid)
{
methodInfo = potentialMethod;
break;
}
}
}
if (methodInfo == null)
{
throw new InvalidOperationException($"Invalid method name {method.MethodName}");
}
var returnObject = methodInfo.Invoke(instance, methodParameters?.ToArray());
if (result == null)
{
// this method doesn't have return type
}
else
{
Helpers.PackValue(returnObject, result);
}
}
}