void ICollectionPropertyBagVisitor.Visit <TCollection, TElement>(ICollectionPropertyBag <TCollection, TElement> properties, ref TCollection container) { var path = Path; // This query engine filter is provided with two delegates: // // parameterTransformer: This function is responsible for transforming the input string into a strong generic type. // this is done via the `TypeConversion` API in properties. // // filterResolver: This function takes the data for each element being filtered, along with the original token, and the // transformed input. The function then applies the filter and returns true or false. In this particular case // we want to test equality with each collection element and return true if ANY match. // QueryEngine.AddFilter <TElement, TElement>(Token, (data, _, token, transformedInput) => { if (!PropertyContainer.TryGetValue <TData, TCollection>(ref data, path, out var collection)) { return(false); } if (RuntimeTypeInfoCache <TCollection> .CanBeNull && null == collection) { return(false); } return(collection.Any(e => FilterOperator.ApplyOperator(token, e, transformedInput, QueryEngine.globalStringComparison))); }, s => TypeConversion.Convert <string, TElement>(ref s), FilterOperator.GetSupportedOperators <TElement>()); }
private void ToggleBool() { Variable var = ObjectController.Get().GetObject <Variable>(ObjectCategories.Variable, Name); var.Value = TypeConversion.Convert(typeof(bool), Value.ToString()); Debug.Log("Bool Toggled: " + var.Name + " Value: " + var.Value.ToString()); }
public static void Custom_Convert_Interface_To_String_NoImpl() { Assert.Throws <Exception>(() => { TypeConversion.Convert <string>(new TestClass()); }); }
public override VisualElement Build() { base.Build(); var range = DrawerAttribute; var lowValue = Mathf.Max(range.min, LowValue); var highValue = Mathf.Min(range.max, HighValue); m_Field.lowValue = TypeConversion.Convert <float, TFieldType>(ref lowValue); m_Field.highValue = TypeConversion.Convert <float, TFieldType>(ref highValue); var root = new VisualElement(); root.Add(m_Field); m_Field.style.flexGrow = 1; m_ValueField = new FloatField { name = Name, label = null, tooltip = Tooltip, }; m_ValueField.formatString = "0.##"; m_ValueField.RegisterValueChangedCallback(OnChanged); m_ValueField.style.flexGrow = 0; m_ValueField.style.width = 50; root.Add(m_ValueField); root.style.flexDirection = FlexDirection.Row; return(root); }
public static Expression GetParamsMatch(Type type, Expression instance, string membername, List <Expression> args) { // assume params var methodInfos = type.GetMethods().Where(x => x.Name == membername); var matchScore = new List <Tuple <MethodInfo, int> >(); foreach (var info in methodInfos.OrderByDescending(m => m.GetParameters().Count())) { var parameterInfos = info.GetParameters(); var lastParam = parameterInfos.Last(); var newArgs = args.Take(parameterInfos.Length - 1).ToList(); var paramArgs = args.Skip(parameterInfos.Length - 1).ToList(); int i = 0; int k = 0; foreach (var expression in newArgs) { k += TypeConversion.CanConvert(expression.Type, parameterInfos[i].ParameterType); i++; } if (k > 0) { if (Attribute.IsDefined(lastParam, typeof(ParamArrayAttribute))) { k += paramArgs.Sum(arg => TypeConversion.CanConvert(arg.Type, lastParam.ParameterType.GetElementType())); } } matchScore.Add(new Tuple <MethodInfo, int>(info, k)); } var info2 = matchScore.OrderBy(x => x.Item2).FirstOrDefault(x => x.Item2 >= 0); if (info2 != null) { var parameterInfos2 = info2.Item1.GetParameters(); var lastParam2 = parameterInfos2.Last(); var newArgs2 = args.Take(parameterInfos2.Length - 1).ToList(); var paramArgs2 = args.Skip(parameterInfos2.Length - 1).ToList(); for (int i = 0; i < parameterInfos2.Length - 1; i++) { newArgs2[i] = TypeConversion.Convert(newArgs2[i], parameterInfos2[i].ParameterType); } var targetType = lastParam2.ParameterType.GetElementType(); newArgs2.Add(Expression.NewArrayInit(targetType, paramArgs2.Select(x => TypeConversion.Convert(x, targetType)))); return(Expression.Call(instance, info2.Item1, newArgs2)); } return(null); }
private void CheckForValueOrName() { Var = ObjectController.Get().GetObject <Variable>(ObjectCategories.Variable, Name); if (Val == null) { Comparer = (float)TypeConversion.Convert(typeof(float), Value); } }
protected override VisitStatus Visit <TProperty, TContainer, TValue>(TProperty property, ref TContainer container, ref TValue value, ref ChangeTracker changeTracker) { if (string.Equals(property.GetName(), Name)) { value = TypeConversion.Convert <object, TValue>(Value); } return(base.Visit(property, ref container, ref value, ref changeTracker)); }
public override VisualElement Build(InspectorContext <TValue> context) { base.Build(context); var range = context.Attributes.GetAttribute <RangeAttribute>(); m_Field.lowValue = TypeConversion.Convert <float, TFieldType>(Mathf.Max(range.min, LowValue)); m_Field.highValue = TypeConversion.Convert <float, TFieldType>(Mathf.Min(range.max, HighValue)); return(m_Field); }
public override void Update() { var value = TypeConversion.Convert <TValue, float>(Target); if (value != m_ValueField.value) { m_ValueField.SetValueWithoutNotify(TypeConversion.Convert <TValue, float>(Target)); } }
void OnChanged(ChangeEvent <float> evt) { var clampedValue = Mathf.Clamp(evt.newValue, DrawerAttribute.min, DrawerAttribute.max); var value = TypeConversion.Convert <float, TValue>(ref clampedValue); if (!value.Equals(Target)) { Target = value; Update(); } }
public static Expression BinaryOperatorFunc( OpFuncArgs args ) { Expression re = args.ExprStack.Pop(); Expression le = args.ExprStack.Pop(); // perform implicit conversion on known types TypeConversion.Convert(ref le, ref re); return(((BinaryOperator)args.Op).Func(le, re)); }
public static void Custom_Convert_Interface_To_String() { TypeConversion.Register <ITestInterface, string>(v => "Test"); try { Assert.AreEqual("Test", TypeConversion.Convert <string>(new TestClass())); } finally { TypeConversion.Unregister <ITestInterface, string>(); } }
public static void Custom_Convert_String_To_Class() { TypeConversion.Register <string, TestClass>(v => new TestClass(/* v */)); try { Assert.IsNotNull(TypeConversion.Convert <TestClass>("Test")); } finally { TypeConversion.Unregister <string, TestClass>(); } }
public static Expression TernaryOperatorFunc(OpFuncArgs args) { Expression falsy = args.ExprStack.Pop(); Expression truthy = args.ExprStack.Pop(); Expression condition = args.ExprStack.Pop(); if (condition.Type != typeof(bool)) { condition = Expression.Convert(condition, typeof(bool)); } // perform implicit conversion on known types ??? TypeConversion.Convert(ref falsy, ref truthy); return(((TernaryOperator)args.Op).Func(condition, truthy, falsy)); }
public static Expression GetExactMatch(Type type, Expression instance, string membername, List <Expression> args) { var argTypes = args.Select(x => x.Type); // Look for an exact match var methodInfo = type.GetMethod(membername, argTypes.ToArray()); if (methodInfo != null) { var parameterInfos = methodInfo.GetParameters(); for (int i = 0; i < parameterInfos.Length; i++) { args[i] = TypeConversion.Convert(args[i], parameterInfos[i].ParameterType); } return(Expression.Call(instance, methodInfo, args)); } return(null); }
public static Expression BinaryOperatorFunc(OpFuncArgs args) { Expression re = args.ExprStack.Pop(); Expression le = args.ExprStack.Pop(); // perform implicit conversion on known types //var isDynamic = le.Type.GetInterfaces().Contains(typeof(IDynamicMetaObjectProvider)) || // le.Type == typeof(Object); if (le.Type.IsDynamic() && re.Type.IsDynamic()) { var expressionType = args.Op.ExpressionType; if (expressionType == ExpressionType.OrElse) { le = Expression.IsTrue(Expression.Convert(le, typeof(bool))); expressionType = ExpressionType.Or; return(Expression.Condition(le, Expression.Constant(true), Expression.Convert(DynamicBinaryOperatorFunc(Expression.Constant(false), re, expressionType), typeof(bool)))); } if (expressionType == ExpressionType.AndAlso) { le = Expression.IsFalse(Expression.Convert(le, typeof(bool))); expressionType = ExpressionType.And; return(Expression.Condition(le, Expression.Constant(false), Expression.Convert(DynamicBinaryOperatorFunc(Expression.Constant(true), re, expressionType), typeof(bool)))); } return(DynamicBinaryOperatorFunc(le, re, expressionType)); } else { TypeConversion.Convert(ref le, ref re); return(((BinaryOperator)args.Op).Func(le, re)); } }
private static void SetProperty(object obj, string property, string value, string typeOverride = "NullType") { /*Debug.Log("Properties found for " + obj.GetType().ToString() + ":"); * foreach (PropertyInfo p in obj.GetType().GetProperties()) * { * Debug.Log(p.Name); * }*/ if (property == "Value") { Debug.Log("Working With Value"); } PropertyInfo pInfo = obj.GetType().GetProperty(PP.GetParameterLiteralName(property)); if (pInfo == null) { Debug.LogError(property + " was not found in type " + obj.GetType().ToString()); } else { object val; if (typeOverride == "NullType") { val = TypeConversion.Convert(PP.GetParameterType(property), value); } else { val = TypeConversion.Convert(Type.GetType(typeOverride), value); } pInfo.SetValue(obj, val, null); try { Debug.Log("Successfully set " + property + " for " + obj.GetType().ToString() + " as " + pInfo.GetValue(obj, null).ToString()); } catch { Debug.LogWarning("If not \"Path\", report to programmer: " + pInfo.Name); } // SoundObjs should be the only thing to cause this } }
public void FromJson(string json) { if (string.IsNullOrEmpty(json)) { return; } object workspaceObject; Properties.Serialization.Json.TryDeserializeObject(json, out workspaceObject); var workspaceDictionary = workspaceObject as IDictionary <string, object>; if (null != workspaceDictionary) { ActiveEntityGroup = Parser.ParseSceneReference(Parser.GetValue(workspaceDictionary, s_ActiveEntityGroupProperty.Name)); object openedScenesObject; workspaceDictionary.TryGetValue(s_OpenedEntityGroupsProperty.Name, out openedScenesObject); var openedScenesList = openedScenesObject as IList <object>; if (null != openedScenesList) { foreach (var obj in openedScenesList) { OpenedEntityGroups.Add(Parser.ParseSceneReference(obj)); } } if (workspaceDictionary.ContainsKey(s_PreviewProperty.Name)) { Preview = TypeConversion.Convert <bool>(Parser.GetValue(workspaceDictionary, s_PreviewProperty.Name)); } if (workspaceDictionary.ContainsKey(s_BuildConfigurationProperty.Name)) { BuildConfiguration = (UTinyBuildConfiguration)TypeConversion.Convert <int>(Parser.GetValue(workspaceDictionary, s_BuildConfigurationProperty.Name)); } } }
public static void BuiltIn_Convert_Enum_To_Int() { Assert.AreEqual(3, TypeConversion.Convert <int>(TestEnum.Fourth)); }
public static void BuiltIn_Convert_Int_To_Enum() { Assert.AreEqual(TestEnum.Third, TypeConversion.Convert <TestEnum>(2)); }
public static void BuiltIn_Convert_Enum_To_String() { Assert.AreEqual("Second", TypeConversion.Convert <string>(TestEnum.Second)); }
public static void BuiltIn_Convert_String_To_Enum() { Assert.AreEqual(TestEnum.First, TypeConversion.Convert <TestEnum>("First")); }
public static void BuiltIn_Convert_String_To_Int() { Assert.AreEqual(10, TypeConversion.Convert <int>("10")); }
public static void BuiltIn_Convert_Int_To_String() { Assert.AreEqual("10", TypeConversion.Convert <string>(10)); }
/// <summary> /// Returns an Expression that accesses a member on an Expression /// </summary> /// <param name="le">The expression that contains the member to be accessed</param> /// <param name="membername">The name of the member to access</param> /// <param name="args">Optional list of arguments to be passed if the member is a method</param> /// <returns></returns> public static Expression MemberAccess(Expression le, string membername, List <Expression> args) { List <Type> argTypes = new List <Type>(); args.ForEach(x => argTypes.Add(x.Type)); Expression instance = null; Type type = null; if (le.Type.Name == "RuntimeType") { type = ((Type)((ConstantExpression)le).Value); } else { type = le.Type; instance = le; } MethodInfo mi = type.GetMethod(membername, argTypes.ToArray()); if (mi != null) { ParameterInfo[] pi = mi.GetParameters(); for (int i = 0; i < pi.Length; i++) { args[i] = TypeConversion.Convert(args[i], pi[i].ParameterType); } return(Expression.Call(instance, mi, args)); } else { Expression exp = null; PropertyInfo pi = type.GetProperty(membername); if (pi != null) { exp = Expression.Property(instance, pi); } else { FieldInfo fi = type.GetField(membername); if (fi != null) { exp = Expression.Field(instance, fi); } } if (exp != null) { if (args.Count > 0) { return(Expression.ArrayAccess(exp, args)); } else { return(exp); } } else { throw new Exception(string.Format("Member not found: {0}.{1}", le.Type.Name, membername)); } } }
/// <summary> /// Returns an Expression that accesses a member on an Expression /// </summary> /// <param name="isFunction">Determines whether the member being accessed is a function or a property</param> /// <param name="isCall">Determines whether the member returns void</param> /// <param name="le">The expression that contains the member to be accessed</param> /// <param name="membername">The name of the member to access</param> /// <param name="args">Optional list of arguments to be passed if the member is a method</param> /// <returns></returns> public static Expression MemberAccess(bool isFunction, bool isCall, Expression le, string membername, List <Expression> args) { var argTypes = args.Select(x => x.Type); Expression instance = null; Type type = null; var isDynamic = false; var isRuntimeType = false; if (le.Type.Name == "RuntimeType") { isRuntimeType = true; type = ((Type)((ConstantExpression)le).Value); } else { type = le.Type; instance = le; isDynamic = type.IsDynamic(); } if (isFunction) { if (isDynamic) { var expArgs = new List <Expression> { instance }; expArgs.AddRange(args); if (isCall) { var binderMC = Binder.InvokeMember( CSharpBinderFlags.ResultDiscarded, membername, null, type, expArgs.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)) ); return(Expression.Dynamic(binderMC, typeof(void), expArgs)); } var binderM = Binder.InvokeMember( CSharpBinderFlags.None, membername, null, type, expArgs.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)) ); return(Expression.Dynamic(binderM, typeof(object), expArgs)); } else { var mis = MethodResolution.GetApplicableMembers(type, membername, args); var methodInfo = (MethodInfo)mis[0]; if (methodInfo != null) { var parameterInfos = methodInfo.GetParameters(); foreach (var parameterInfo in parameterInfos) { var index = parameterInfo.Position; args[index] = TypeConversion.Convert(args[index], parameterInfo.ParameterType); } return(Expression.Call(instance, methodInfo, args.ToArray())); } var match = MethodResolution.GetExactMatch(type, instance, membername, args) ?? MethodResolution.GetParamsMatch(type, instance, membername, args); if (match != null) { return(match); } } } else { if (isDynamic) { var binder = Binder.GetMember( CSharpBinderFlags.None, membername, type, new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) } ); var result = Expression.Dynamic(binder, typeof(object), instance); if (args.Count > 0) { var expArgs = new List <Expression>() { result }; expArgs.AddRange(args); var indexedBinder = Binder.GetIndex( CSharpBinderFlags.None, type, expArgs.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)) ); result = Expression.Dynamic(indexedBinder, typeof(object), expArgs); } return(result); } else { Expression exp = null; var propertyInfo = type.GetProperty(membername); if (propertyInfo != null) { exp = Expression.Property(instance, propertyInfo); } else { var fieldInfo = type.GetField(membername); if (fieldInfo != null) { exp = Expression.Field(instance, fieldInfo); } } if (exp != null) { if (args.Count > 0) { return(Expression.ArrayAccess(exp, args)); } else { return(exp); } } } } throw new Exception(string.Format("Member not found: {0}.{1}", le.Type.Name, membername)); }
protected override void OnChanged(ChangeEvent <TFieldValue> evt, InspectorContext <TValue> context) { context.Data = Connector.ToValue( TypeConversion.Convert <float, TFieldValue>( Mathf.Max(m_MinValue, TypeConversion.Convert <TFieldValue, float>(evt.newValue)))); }