private static void EmitNullableToNullableConversion(this ILGenerator ilGenerator, TypeInfo typeFrom, TypeInfo typeTo, bool isChecked) { Label labIfNull = default(Label); Label labEnd = default(Label); LocalBuilder locFrom = null; LocalBuilder locTo = null; locFrom = ilGenerator.DeclareLocal(typeFrom.AsType()); ilGenerator.Emit(OpCodes.Stloc, locFrom); locTo = ilGenerator.DeclareLocal(typeTo.AsType()); // test for null ilGenerator.Emit(OpCodes.Ldloca, locFrom); ilGenerator.EmitHasValue(typeFrom.AsType()); labIfNull = ilGenerator.DefineLabel(); ilGenerator.Emit(OpCodes.Brfalse_S, labIfNull); ilGenerator.Emit(OpCodes.Ldloca, locFrom); ilGenerator.EmitGetValueOrDefault(typeFrom.AsType()); Type nnTypeFrom = TypeInfoUtils.GetNonNullableType(typeFrom); Type nnTypeTo = TypeInfoUtils.GetNonNullableType(typeTo); ilGenerator.EmitConvertToType(nnTypeFrom, nnTypeTo, isChecked); // construct result type ConstructorInfo ci = typeTo.GetConstructor(new Type[] { nnTypeTo }); ilGenerator.Emit(OpCodes.Newobj, ci); ilGenerator.Emit(OpCodes.Stloc, locTo); labEnd = ilGenerator.DefineLabel(); ilGenerator.Emit(OpCodes.Br_S, labEnd); // if null then create a default one ilGenerator.MarkLabel(labIfNull); ilGenerator.Emit(OpCodes.Ldloca, locTo); ilGenerator.Emit(OpCodes.Initobj, typeTo.AsType()); ilGenerator.MarkLabel(labEnd); ilGenerator.Emit(OpCodes.Ldloc, locTo); }
public bool Set <T>(string variableKey, T value = default(T), bool skipIfExists = false) { string variable = ParameterDicUtils.GetVariable(variableKey); string[] variableSplit = variable.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries); if (variableSplit.Length > 1) { //If have more than one hierarchy (e.g. {Code.Directory.Temp}) //Remove last node, and construct as variable key (e.g. {Code.Directory})) string parentKey = "{" + String.Join(".", variableSplit.Take(variableSplit.Length - 1)) + "}"; string childPath = variableSplit.Last(); string childKey = "{" + childPath + "}"; object parentObject = Get(parentKey); //If ParentObject not found, create as ParameterDic. if (parentObject == null) { parentObject = new ParameterDic(); Set <ParameterDic>(parentKey, (ParameterDic)parentObject, false); } if (parentObject is IParameterDic) { (parentObject as IParameterDic).Set <T>(childKey, value, skipIfExists); return(true); } else { TypeInfoUtils.SetProperty(parentObject, childPath, value); return(true); } } else if (_store.ContainsKey(variable)) { if (!skipIfExists) { if (!(_store[variable] is T) || !(_store[variable].Equals(value))) { _store[variable] = value; return(true); } else { return(false); } } else { return(false); } } else { _store.Add(variable, value); return(true); } }
public bool SetValue <T>(string variableKey, T value, bool skipIfExists = false) { if (variableKey == null) { return(false); } string variable = GetVariable(variableKey); string[] variableSplit = variable.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries); if (variableSplit.Length > 1) { string parentKey = "{" + String.Join(".", variableSplit.Take(variableSplit.Length - 1)) + "}"; string childPath = variableSplit.Last(); string childKey = "{" + childPath + "}"; object parentObject = GetValue(parentKey); if (parentObject is ParameterDic) { (parentObject as ParameterDic).SetValue <T>(childKey, value, skipIfExists); return(true); } else { if (parentObject != null) { TypeInfoUtils.SetProperty(parentObject, childPath, value); return(true); } } return(false); } else if (_store.ContainsKey(variable)) { if (!skipIfExists) { if (!(_store[variable] is T) || !(_store[variable].Equals(value))) { this[variable] = value; return(true); } else { return(false); } } else { return(false); } } else { _store.Add(variable, value); return(true); } }
public static void EmitConvertToType(this ILGenerator ilGenerator, Type typeFrom, Type typeTo, bool isChecked = true) { if (ilGenerator == null) { throw new ArgumentNullException(nameof(ilGenerator)); } if (typeFrom == null) { throw new ArgumentNullException(nameof(typeFrom)); } if (typeTo == null) { throw new ArgumentNullException(nameof(typeTo)); } var typeFromInfo = typeFrom.GetTypeInfo(); var typeToInfo = typeTo.GetTypeInfo(); var nnExprType = typeFromInfo.GetNonNullableType(); var nnType = typeToInfo.GetNonNullableType(); if (TypeInfoUtils.AreEquivalent(typeFromInfo, typeToInfo)) { return; } if (typeFromInfo.IsInterface || // interface cast typeToInfo.IsInterface || typeFrom == typeof(object) || // boxing cast typeTo == typeof(object) || typeFrom == typeof(System.Enum) || typeFrom == typeof(System.ValueType) || TypeInfoUtils.IsLegalExplicitVariantDelegateConversion(typeFromInfo, typeToInfo)) { ilGenerator.EmitCastToType(typeFromInfo, typeToInfo); } else if (typeFromInfo.IsNullableType() || typeToInfo.IsNullableType()) { ilGenerator.EmitNullableConversion(typeFromInfo, typeToInfo, isChecked); } else if (!(typeFromInfo.IsConvertible() && typeToInfo.IsConvertible()) // primitive runtime conversion && (nnExprType.GetTypeInfo().IsAssignableFrom(nnType) || // down cast nnType.GetTypeInfo().IsAssignableFrom(nnExprType))) // up cast { ilGenerator.EmitCastToType(typeFromInfo, typeToInfo); } else if (typeFromInfo.IsArray && typeToInfo.IsArray) { // See DevDiv Bugs #94657. ilGenerator.EmitCastToType(typeFromInfo, typeToInfo); } else { ilGenerator.EmitNumericConversion(typeFromInfo, typeToInfo, isChecked); } }
/** * A required option that sets the object inspector for the rows. If * setSchema is not called, it also defines the schema. */ public WriterOptions inspector(ObjectInspector value) { _inspector = value; if (!explicitSchema) { schema = OrcUtils.convertTypeInfo( TypeInfoUtils.getTypeInfoFromObjectInspector(value)); } return(this); }
private static void EmitNullableToNonNullableStructConversion(this ILGenerator ilGenerator, TypeInfo typeFrom, TypeInfo typeTo, bool isChecked) { LocalBuilder locFrom = null; locFrom = ilGenerator.DeclareLocal(typeFrom.AsType()); ilGenerator.Emit(OpCodes.Stloc, locFrom); ilGenerator.Emit(OpCodes.Ldloca, locFrom); ilGenerator.EmitGetValue(typeFrom.AsType()); Type nnTypeFrom = TypeInfoUtils.GetNonNullableType(typeFrom); ilGenerator.EmitConvertToType(nnTypeFrom, typeTo.AsType(), isChecked); }
/// <summary> /// Returns the current data value, converted to the specified type. /// </summary> /// <param name="type">Desired type of data.</param> /// <returns>Current data value, converted to the specified type.</returns> /// <exception cref="System.InvalidCastException">Thrown if the data value can't be cast to the specified type.</exception> public object GetValue(Type type) { var rawValue = this.Value; if (rawValue == null) { return(TypeInfoUtils.IsValueType(type) ? Activator.CreateInstance(type) : null); } object convertedValue; return(ReflectionUtils.TryConvertValue(rawValue, type, out convertedValue) ? convertedValue : rawValue); }
/** * Convert a Hive type property string that contains separated type names into a list of * TypeDescription objects. * @return the list of TypeDescription objects. */ public static List <TypeDescription> typeDescriptionsFromHiveTypeProperty(string hiveTypeProperty) { // CONSDIER: We need a type name parser for TypeDescription. List <TypeInfo> typeInfoList = TypeInfoUtils.getTypeInfosFromTypeString(hiveTypeProperty); List <TypeDescription> typeDescrList = new List <TypeDescription>(typeInfoList.Count); foreach (TypeInfo typeInfo in typeInfoList) { typeDescrList.Add(convertTypeInfo(typeInfo)); } return(typeDescrList); }
private static void EmitNonNullableToNullableConversion(this ILGenerator ilGenerator, TypeInfo typeFrom, TypeInfo typeTo, bool isChecked) { LocalBuilder locTo = null; locTo = ilGenerator.DeclareLocal(typeTo.AsType()); Type nnTypeTo = TypeInfoUtils.GetNonNullableType(typeTo); ilGenerator.EmitConvertToType(typeFrom.AsType(), nnTypeTo, isChecked); ConstructorInfo ci = typeTo.GetConstructor(new Type[] { nnTypeTo }); ilGenerator.Emit(OpCodes.Newobj, ci); ilGenerator.Emit(OpCodes.Stloc, locTo); ilGenerator.Emit(OpCodes.Ldloc, locTo); }
public void testInspectorFromTypeInfo() { TypeInfo typeInfo = TypeInfoUtils.getTypeInfoFromTypeString("struct<c1:boolean,c2:tinyint" + ",c3:smallint,c4:int,c5:bigint,c6:float,c7:double,c8:binary," + "c9:string,c10:struct<c1:int>,c11:map<int,int>,c12:uniontype<int>" + ",c13:array<timestamp>>"); StructObjectInspector inspector = (StructObjectInspector) OrcStruct.createObjectInspector(typeInfo); Assert.Equal("struct<c1:boolean,c2:tinyint,c3:smallint,c4:int,c5:" + "bigint,c6:float,c7:double,c8:binary,c9:string,c10:struct<" + "c1:int>,c11:map<int,int>,c12:uniontype<int>,c13:array<timestamp>>", inspector.getTypeName()); Assert.Equal(null, inspector.getAllStructFieldRefs()[0].getFieldComment()); Assert.Equal(null, inspector.getStructFieldRef("UNKNOWN")); OrcStruct s1 = new OrcStruct(13); for (int i = 0; i < 13; ++i) { s1.setFieldValue(i, i); } List <object> list = new List <object> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; Assert.Equal(list, inspector.getStructFieldsDataAsList(s1)); ListObjectInspector listOI = (ListObjectInspector) inspector.getAllStructFieldRefs()[12].getFieldObjectInspector(); Assert.Equal(ObjectInspectorCategory.LIST, listOI.getCategory()); Assert.Equal(10, listOI.getListElement(list, 10)); Assert.Equal(null, listOI.getListElement(list, -1)); Assert.Equal(null, listOI.getListElement(list, 13)); Assert.Equal(13, listOI.getListLength(list)); Dictionary <object, object> map = new Dictionary <object, object>() { { 1, 2 }, { 2, 4 }, { 3, 6 }, }; MapObjectInspector mapOI = (MapObjectInspector) inspector.getAllStructFieldRefs()[10].getFieldObjectInspector(); Assert.Equal(3, mapOI.getMapSize(map)); Assert.Equal(4, mapOI.getMapValueElement(map, 2)); }
private static void EmitNullableConversion(this ILGenerator ilGenerator, TypeInfo typeFrom, TypeInfo typeTo, bool isChecked) { bool isTypeFromNullable = TypeInfoUtils.IsNullableType(typeFrom); bool isTypeToNullable = TypeInfoUtils.IsNullableType(typeTo); if (isTypeFromNullable && isTypeToNullable) { ilGenerator.EmitNullableToNullableConversion(typeFrom, typeTo, isChecked); } else if (isTypeFromNullable) { ilGenerator.EmitNullableToNonNullableConversion(typeFrom, typeTo, isChecked); } else { ilGenerator.EmitNonNullableToNullableConversion(typeFrom, typeTo, isChecked); } }
public T GetValue <T>(string variableKey, T defaultValue) { if (variableKey == null) { return(defaultValue); } string variable = GetVariable(variableKey); string[] variableSplit = variable.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries); var match = Regex.Match(variableSplit[0], RegexPatterns.ParseArrayCounterPattern); string varName = match.Groups["variable"].Value; int idx = match.Groups["counter"].Success ? Int32.Parse(match.Groups["counter"].Value) : -1; if (_store.ContainsKey(varName)) { object initValue = _store[varName]; if (initValue == null) { return(default(T)); } if (initValue is ParameterDic && idx == -1 && variableSplit.Length > 1) { //Omit the first variable. string trailVariable = "{" + String.Join(".", variableSplit.Skip(1).ToArray()) + "}"; return((initValue as ParameterDic).GetValue <T>(trailVariable)); } if (idx != -1 && initValue is Array) { initValue = (initValue as Array).GetValue(idx); } var val = TypeInfoUtils.GetPropertyOrMethod(initValue, variableSplit.Skip(1).ToArray()); if (val is T) { return((T)val); } } return(defaultValue); }
private static void EmitNumericConversion(this ILGenerator ilGenerator, TypeInfo typeFrom, TypeInfo typeTo, bool isChecked) { bool isFromUnsigned = TypeInfoUtils.IsUnsigned(typeFrom); bool isFromFloatingPoint = TypeInfoUtils.IsFloatingPoint(typeFrom); if (typeTo.AsType() == typeof(Single)) { if (isFromUnsigned) { ilGenerator.Emit(OpCodes.Conv_R_Un); } ilGenerator.Emit(OpCodes.Conv_R4); } else if (typeTo.AsType() == typeof(Double)) { if (isFromUnsigned) { ilGenerator.Emit(OpCodes.Conv_R_Un); } ilGenerator.Emit(OpCodes.Conv_R8); } else { TypeCode tc = Type.GetTypeCode(typeTo.AsType()); if (isChecked) { // Overflow checking needs to know if the source value on the IL stack is unsigned or not. if (isFromUnsigned) { switch (tc) { case TypeCode.SByte: ilGenerator.Emit(OpCodes.Conv_Ovf_I1_Un); break; case TypeCode.Int16: ilGenerator.Emit(OpCodes.Conv_Ovf_I2_Un); break; case TypeCode.Int32: ilGenerator.Emit(OpCodes.Conv_Ovf_I4_Un); break; case TypeCode.Int64: ilGenerator.Emit(OpCodes.Conv_Ovf_I8_Un); break; case TypeCode.Byte: ilGenerator.Emit(OpCodes.Conv_Ovf_U1_Un); break; case TypeCode.UInt16: case TypeCode.Char: ilGenerator.Emit(OpCodes.Conv_Ovf_U2_Un); break; case TypeCode.UInt32: ilGenerator.Emit(OpCodes.Conv_Ovf_U4_Un); break; case TypeCode.UInt64: ilGenerator.Emit(OpCodes.Conv_Ovf_U8_Un); break; default: throw new InvalidCastException(); } } else { switch (tc) { case TypeCode.SByte: ilGenerator.Emit(OpCodes.Conv_Ovf_I1); break; case TypeCode.Int16: ilGenerator.Emit(OpCodes.Conv_Ovf_I2); break; case TypeCode.Int32: ilGenerator.Emit(OpCodes.Conv_Ovf_I4); break; case TypeCode.Int64: ilGenerator.Emit(OpCodes.Conv_Ovf_I8); break; case TypeCode.Byte: ilGenerator.Emit(OpCodes.Conv_Ovf_U1); break; case TypeCode.UInt16: case TypeCode.Char: ilGenerator.Emit(OpCodes.Conv_Ovf_U2); break; case TypeCode.UInt32: ilGenerator.Emit(OpCodes.Conv_Ovf_U4); break; case TypeCode.UInt64: ilGenerator.Emit(OpCodes.Conv_Ovf_U8); break; default: throw new InvalidCastException(); } } } else { switch (tc) { case TypeCode.SByte: ilGenerator.Emit(OpCodes.Conv_I1); break; case TypeCode.Byte: ilGenerator.Emit(OpCodes.Conv_U1); break; case TypeCode.Int16: ilGenerator.Emit(OpCodes.Conv_I2); break; case TypeCode.UInt16: case TypeCode.Char: ilGenerator.Emit(OpCodes.Conv_U2); break; case TypeCode.Int32: ilGenerator.Emit(OpCodes.Conv_I4); break; case TypeCode.UInt32: ilGenerator.Emit(OpCodes.Conv_U4); break; case TypeCode.Int64: if (isFromUnsigned) { ilGenerator.Emit(OpCodes.Conv_U8); } else { ilGenerator.Emit(OpCodes.Conv_I8); } break; case TypeCode.UInt64: if (isFromUnsigned || isFromFloatingPoint) { ilGenerator.Emit(OpCodes.Conv_U8); } else { ilGenerator.Emit(OpCodes.Conv_I8); } break; default: throw new InvalidCastException(); } } } }
public static object DrawValueField(string memberName, Type memberType, object memberValue, Func <string, Type, object, object> fallbackAction = null) { if (memberValue == null) { if (memberType.IsValueType) { memberValue = Activator.CreateInstance(memberType); } } if (memberType == typeof(int)) { return(EditorGUILayout.IntField(memberName, (int)memberValue)); } if (memberType == typeof(long)) { return(EditorGUILayout.LongField(memberName, (long)memberValue)); } if (memberType == typeof(float)) { return(EditorGUILayout.FloatField(memberName, (float)memberValue)); } if (memberType == typeof(bool)) { return(EditorGUILayout.Toggle(memberName, (bool)memberValue)); } if (memberType == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(memberName, (Vector2)memberValue)); } if (memberType == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(memberName, (Vector3)memberValue)); } if (memberType == typeof(Vector4)) { return(EditorGUILayout.Vector4Field(memberName, (Vector4)memberValue)); } if (memberType == typeof(string)) { return(EditorGUILayout.TextField(memberName, (string)memberValue)); } if (TypeInfoUtils.IsEnum(memberType)) { return(EditorGUILayout.EnumPopup(memberName, (Enum)memberValue)); } var unityObjectType = typeof(Object); if (unityObjectType.IsAssignableFrom(memberType)) { return(EditorGUILayout.ObjectField(memberName, (Object)memberValue, memberType, true)); } return(fallbackAction == null ? DrawValueFieldFallback(memberName, memberType, memberValue) : fallbackAction(memberName, memberType, memberValue)); }
private void DrawDictionaryData(DataDictionary dataDictionary, int level) { var prevIndentLevel = EditorGUI.indentLevel; EditorGUI.indentLevel = level; Dictionary <object, object> changedValues = null; foreach (var key in dataDictionary.Keys) { var value = dataDictionary[key]; var newValue = this.DrawMemberData("Item " + key, dataDictionary.ValueType, value, level); if (!Equals(value, newValue)) { if (changedValues == null) { changedValues = new Dictionary <object, object>(); } changedValues[key] = newValue; } } if (changedValues != null) { foreach (var key in changedValues.Keys) { dataDictionary[key] = changedValues[key]; } } GUILayout.BeginHorizontal(); object newKey; this.newKeys.TryGetValue(dataDictionary, out newKey); var keyType = dataDictionary.KeyType; const string NewKeyLabel = "New:"; if (keyType == typeof(string)) { this.newKeys[dataDictionary] = newKey = EditorGUILayout.TextField(NewKeyLabel, (string)newKey); } else if (TypeInfoUtils.IsEnum(keyType)) { if (newKey == null) { newKey = Enum.GetValues(keyType).GetValue(0); } this.newKeys[dataDictionary] = newKey = EditorGUILayout.EnumPopup(NewKeyLabel, (Enum)newKey); } if (GUILayout.Button("+") && newKey != null) { var valueType = dataDictionary.ValueType; dataDictionary.Add(newKey, valueType.IsValueType ? Activator.CreateInstance(valueType) : null); } GUILayout.EndHorizontal(); EditorGUI.indentLevel = prevIndentLevel; }
/// <summary> /// Invokes the bound method with the specified arguments. /// </summary> /// <param name="args">Arguments to invoke the bound method with.</param> public void InvokeCommand(params object[] args) { if (this.command == null) { return; } // Add additional arguments if there are any. var commandArgs = args; var additionalArgCount = this.AdditionalArguments.Length; if (additionalArgCount > 0) { var argList = new List <object>(); argList.AddRange(args); argList.AddRange( this.AdditionalArguments.Select( additionArgument => additionArgument != null ? additionArgument.Value : null)); commandArgs = argList.ToArray(); } // Use default parameters if more are required than provided. var methodInfo = TypeInfoUtils.GetMethodInfo(this.command); var parameterInfos = methodInfo.GetParameters(); if (parameterInfos.Length > commandArgs.Length) { var argList = new List <object>(); argList.AddRange(commandArgs); for (var index = commandArgs.Length; index < parameterInfos.Length; index++) { var parameterInfo = parameterInfos[index]; var defaultValue = TypeInfoUtils.IsValueType(parameterInfo.ParameterType) ? Activator.CreateInstance(parameterInfo.ParameterType) : null; argList.Add(defaultValue); } commandArgs = argList.ToArray(); } // Skip base arguments if less are required. else if (parameterInfos.Length < commandArgs.Length) { var argList = new List <object>(); var baseArgCount = parameterInfos.Length - additionalArgCount; for (var index = 0; index < baseArgCount; index++) { argList.Add(args[index]); } // Add additional arguments. argList.AddRange( this.AdditionalArguments.Select( additionArgument => additionArgument != null ? additionArgument.Value : null)); commandArgs = argList.ToArray(); } try { // Invoke delegate. this.command.DynamicInvoke(commandArgs); } catch (Exception e) { if (e is ArgumentException || e is TargetParameterCountException) { Debug.LogError( string.Format( "Couldn't invoke command '{0}' with arguments: [{1}]. (Exception: {2})", this.Path, commandArgs.Aggregate( string.Empty, (text, arg) => (string.IsNullOrEmpty(text) ? string.Empty : text + ", ") + (arg != null ? arg.ToString() : "null")), e), this); } else { throw; } } }