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