private static void ToCSharpString(Type type, StringBuilder name) { if (type.IsArray) { var elementType = type.GetElementType(); ToCSharpString(elementType, name); name.Append(type.Name.Substring(elementType.Name.Length)); return; } if (type.IsGenericParameter) { //NOTE: this has to go before type.IsNested because nested generic type is also a generic parameter and otherwise we'd have stack overflow name.AppendFormat("·{0}·", type.Name); return; } if (type.IsNested) { ToCSharpString(type.DeclaringType, name); name.Append("."); } if (type.IsGenericType == false) { name.Append(type.Name); return; } name.Append(type.Name.Split('`')[0]); AppendGenericParameters(name, type.GetGenericArguments()); }
public static Type GetClosedParameterType(AbstractTypeEmitter type, Type parameter) { if (parameter.IsGenericTypeDefinition) { return parameter.GetGenericTypeDefinition().MakeGenericType(type.GetGenericArgumentsFor(parameter)); } if (parameter.IsGenericType) { Type[] arguments = parameter.GetGenericArguments(); if (CloseGenericParametersIfAny(type, arguments)) { return parameter.GetGenericTypeDefinition().MakeGenericType(arguments); } } if (parameter.IsGenericParameter) { return type.GetGenericArgument(parameter.Name); } if (parameter.IsArray) { var elementType = GetClosedParameterType(type, parameter.GetElementType()); return elementType.MakeArrayType(); } if(parameter.IsByRef) { var elementType = GetClosedParameterType(type, parameter.GetElementType()); return elementType.MakeByRefType(); } return parameter; }
/// <summary> /// Determines if the two types are either identical, or are both generic parameters or generic types /// with generic parameters in the same locations (generic parameters match any other generic paramter, /// but NOT concrete types). /// </summary> private static bool IsSimilarType(this Type thisType, Type type) { // Ignore any 'ref' types if (thisType.IsByRef) thisType = thisType.GetElementType(); if (type.IsByRef) type = type.GetElementType(); // Handle array types if (thisType.IsArray && type.IsArray) return thisType.GetElementType().IsSimilarType(type.GetElementType()); // If the types are identical, or they're both generic parameters or the special 'T' type, treat as a match if (thisType == type || ((thisType.IsGenericParameter || thisType == typeof(T)) && (type.IsGenericParameter || type == typeof(T)))) return true; // Handle any generic arguments if (thisType.IsGenericType && type.IsGenericType) { var thisArguments = thisType.GetGenericArguments(); var arguments = type.GetGenericArguments(); if (thisArguments.Length == arguments.Length) { for (var i = 0; i < thisArguments.Length; ++i) { if (!thisArguments[i].IsSimilarType(arguments[i])) return false; } return true; } } return false; }
private object CreateDefaultType(Type t) { object ret = null; try { if (t.GetElementType() != null) { t = t.GetElementType(); } if (t == typeof(string)) { ret = String.Empty; } else if (t == typeof(IBindCtx)) { ret = COMUtilities.CreateBindCtx(0); } else { /* Try the default activation route */ ret = System.Activator.CreateInstance(t); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); } return ret; }
public object Deserialize(string content, Type objectType) { var xmlDocument = new XmlDocument(); xmlDocument.LoadXml(content); var contents = xmlDocument.DocumentElement.GetElementsByTagName("content"); if(objectType.IsAResource()) { return ToObject(contents[0].InnerText, objectType); } if(objectType.IsAListOfResources()) { var list = Array.CreateInstance(objectType.GetElementType(), contents.Count); for(var i = 0; i < contents.Count; i++) { list.SetValue(ToObject(contents[i].InnerText, objectType.GetElementType()), i); } return list; } return null; }
public static object ParseValue(string rawValue, Type type) { if (string.IsNullOrWhiteSpace(rawValue)) throw new ArgumentNullException("rawValue"); if (type == null) throw new ArgumentNullException("type"); object value; if (type.IsArray) { string[] elements = rawValue.Replace("[", string.Empty).Replace("]", string.Empty).Split(','); Array array = Array.CreateInstance(type.GetElementType(), elements.Length); for (int i = 0; i < array.Length; i++) array.SetValue(Convert.ChangeType(elements[i], type.GetElementType()), i); value = array; } else value = Convert.ChangeType(rawValue, type); return value; }
protected virtual object GetArrayModel( ControllerContext controllerContext, Type modelType, IValueProvider valueProvider, string prefix) { List<object> list = GetListModel(controllerContext, modelType, modelType.GetElementType(), valueProvider, prefix); object[] array = (object[])Array.CreateInstance(modelType.GetElementType(), list.Count); list.CopyTo(array); return array; }
//Get some default data //Walk over an array public string RecursiveArray(object obj, Type t, string[] tokens, int index) { //got to the last token, but still have structure below this node if (index >= tokens.Length) return "Type is complex. Cannot show as string"; //Got to an index in the array that is null if (obj == null) return "Array is null"; //If the type is an array if (t.FullName.Contains("System.Collections.Generic.List") == true) { Array array = ((Array)(t.GetMethod("ToArray").Invoke(obj, null))); //if you requested the length, return the length if (tokens[index] == "length") return array.Length.ToString(); //might have a bad index format try { //try to get the current token as a int int idx = System.Convert.ToInt32(tokens[index]); //check the bounds if (idx >= array.Length) return "index out of bounds"; //Get the object at this position in the array object i = array.GetValue(idx); //If the object in this array is null if (i == null) { //if its a string, create a string if (t.GetElementType() == typeof(String)) array.SetValue("", idx); //else create an object of whatever it was suposed to be else array.SetValue(Activator.CreateInstance(t.GetElementType()), idx); } //Get the new value after null check i = array.GetValue(idx); //If its an array if (i.GetType().FullName.Contains("System.Collections.Generic.List") == true) return RecursiveArray(i, i.GetType(), tokens, index + 1); else return RecursiveGet(i, i.GetType(), tokens, index + 1); } //The format of the array index was incorrect catch (System.FormatException e) { return "Array index invalid"; } } //shoudl not get here, but if we did, then there is no object at this level with the //same name as the token return "Error parsing datamodel parameter string"; }
public static string GetSafeTypeName(Type type) { if (type.IsByRef) { return GetSafeTypeName(type.GetElementType()); } if (type.IsArray) { return GetSafeTypeName(type.GetElementType()) + "[]"; } if (!type.IsGenericType) { return (type.IsGenericParameter) ? type.Name : GetTypePrimitiveName(type); } var generic = type.GetGenericTypeDefinition(); var sb = new StringBuilder(); sb.Append(generic.Name.Substring(0, generic.Name.IndexOf('`'))); sb.Append('<'); int i = 0; foreach (var arg in type.GetGenericArguments()) { if (i++ > 0) { sb.Append(", "); } sb.Append(GetSafeTypeName(arg)); } sb.Append('>'); return sb.ToString(); }
public static string ToPDType(System.Type type) { string pdType = ""; if (type.IsNumerical() || type == typeof(bool) || type == typeof(System.Enum) || type.IsSubclassOf(typeof(System.Enum))) { pdType = type.Name + " -> Float"; } else if (type == typeof(string) || type == typeof(char)) { pdType = type.Name + " -> Symbol"; } else if (type.IsVector() || type == typeof(Quaternion) || type == typeof(Rect) || type == typeof(Color)) { pdType = type.Name + " -> List[Float]"; } else if (type.IsArray) { if (type.GetElementType().IsNumerical() || type.GetElementType() == typeof(bool)) { pdType = type.Name + " -> List[Float]"; } else if (type.GetElementType() == typeof(string) || type.GetElementType() == typeof(char)) { pdType = type.Name + " -> List[Symbol]"; } } return(pdType); }
private static StringBuilder AppendPrettyNameCore(this StringBuilder name, Type type, PrettyNameContext context) { // Suffixes (array, ref, pointer) if (type.IsArray) return name .AppendPrettyName(type.GetElementType(), context) .Append('[') .Append(',', type.GetArrayRank() - 1) .Append(']'); else if (type.IsByRef) return name .AppendPrettyName(type.GetElementType(), context) .Append('&'); else if (type.IsPointer) return name .AppendPrettyName(type.GetElementType(), context) .Append('*'); // Prefixes (nesting, namespace) if (type.IsNested) name.AppendPrettyNameCore(type.DeclaringType, context) .Append('.'); else if (context.IsQualified) name.Append(type.Namespace) .Append('.'); // Name and arguments if (type.IsGenericType) return name .Append(type.Name.WithoutGenericSuffix()) .AppendPrettyArguments(type, context); else return name .Append(type.Name); }
public static string GetFullRefTypeName(Type type) { if (type == typeof(void)) return "void"; if (type.IsByRef) { return GetFullRefTypeName(type.GetElementType()); } if (type.IsArray) { if (type.GetElementType() == typeof(global::org.omg.SDOPackage.NameValue)) { return "Dictionary<string,object>"; } //return "ObservableCollection<" + GetFullRefTypeName(type.GetElementType()) + ">"; return "List<" + GetFullRefTypeName(type.GetElementType()) + ">"; } if (type == typeof(RTC.Time)) return typeof(DateTime).FullName; if (IsPrimitive(type)) return type.FullName; if (IsEnum(type) || IsStruct(type)) return GetFullDataName(type); if (IsInterface(type)) return GetFullName(type); if (IsUnion(type)) return GetIiopName(type); return typeof(object).FullName; }
public static string FromIiop(Type type, string name) { if (type == typeof(void)) return ""; if (type.IsByRef) { return FromIiop(type.GetElementType(), name); } if (type.IsArray) { if (type.GetElementType() == typeof(global::org.omg.SDOPackage.NameValue)) { return "Converter.NVListToDictionary(" + name + ")"; } return name + ".Select(x => (" + GetFullRefTypeName(type.GetElementType()) + ")" + FromIiop(type.GetElementType(), "x") + ").ToList()"; } if (IsPrimitive(type)) return name; if (type == typeof(RTC.Time)) return "Converter.RtcTimeToDateTime(" + name + ")"; if (IsStruct(type)) return "new " + GetFullDataName(type) + "(" + name + ")"; if (IsInterface(type)) return "new " + GetFullName(type) + "Stub(" + name + ")"; if (IsUnion(type)) return name; if (type == typeof(MarshalByRefObject)) return "(object)" + name; //if (IsEnum(type)) return "(" + GetFullName(type)+ ")" + name; }
public static object FitTypeForExternalUse(object o, Type t) { Core.DeReference(ref o); // if type of object is desired type or subtype, fine if (o.GetType() == t || o.GetType().IsSubclassOf(t)) return o; // try to convert an number desired number type else if (o is int || o is double) { if (t == typeof(int)) return System.Convert.ToInt32(o); else if (t == typeof(uint)) return System.Convert.ToUInt32(o); else if (t == typeof(long)) return System.Convert.ToInt64(o); else if (t == typeof(ulong)) return System.Convert.ToUInt64(o); else if (t == typeof(short)) return System.Convert.ToInt16(o); else if (t == typeof(ushort)) return System.Convert.ToUInt16(o); else if (t == typeof(byte)) return System.Convert.ToByte(o); else if (t == typeof(sbyte)) return System.Convert.ToSByte(o); else if (t == typeof(bool)) return System.Convert.ToBoolean(o); else if (t == typeof(float)) return System.Convert.ToSingle(o); else if (t == typeof(double)) return System.Convert.ToDouble(o); else if (t == typeof(decimal)) return System.Convert.ToDecimal(o); else return null; } // try to convert a string to the desired string type else if (o is string) { if (t == typeof(char)) return System.Convert.ToChar((string)o); else return null; } // try to convert an Array to the desired array type else if (o is Array) { if (t == typeof(System.Array) || t.IsArray) { Array arr = (Array)o; System.Array result = System.Array.CreateInstance(t.GetElementType(), arr.Values.Count); for (int i = 0; i < arr.Values.Count; i++) result.SetValue(FitTypeForExternalUse(arr.Values[i], t.GetElementType()), i); return result; } else return null; } else return null; }
public override bool MatchesType(Type t) { Guard.ArgumentNotNull(t, "t"); if (!isArray) { return t.IsGenericParameter && t.Name == genericParameterName; } return t.IsArray && t.GetElementType().IsGenericParameter && t.GetElementType().Name == genericParameterName; }
public object GetService(Type serviceType, Type interfaceType, IServiceLocator context) { ArrayList list = new ArrayList(); foreach (IServiceProvider subsystem in subsystems) { list.Add(subsystem.GetService(serviceType.GetElementType(), interfaceType.GetElementType(), context)); } return list.ToArray(interfaceType.GetElementType()); }
static IReturnType Create(IProjectContent pc, IEntity member, Type type, bool createLazyReturnType, bool forceGenericType) { if (type.IsByRef) { // TODO: Use ByRefRefReturnType return Create(pc, member, type.GetElementType(), createLazyReturnType); } else if (type.IsPointer) { return new PointerReturnType(Create(pc, member, type.GetElementType(), createLazyReturnType)); } else if (type.IsArray) { return new ArrayReturnType(pc, Create(pc, member, type.GetElementType(), createLazyReturnType), type.GetArrayRank()); } else if (type.IsGenericType && (forceGenericType || !type.IsGenericTypeDefinition)) { Type[] args = type.GetGenericArguments(); List<IReturnType> para = new List<IReturnType>(args.Length); for (int i = 0; i < args.Length; ++i) { para.Add(Create(pc, member, args[i], createLazyReturnType)); } return new ConstructedReturnType(Create(pc, member, type.GetGenericTypeDefinition(), createLazyReturnType, false), para); } else if (type.IsGenericParameter) { IClass c = (member is IClass) ? (IClass)member : (member is IMember) ? ((IMember)member).DeclaringType : null; if (c != null && type.GenericParameterPosition < c.TypeParameters.Count) { if (c.TypeParameters[type.GenericParameterPosition].Name == type.Name) { return new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]); } } if (type.DeclaringMethod != null) { IMethod method = member as IMethod; if (method != null) { if (type.GenericParameterPosition < method.TypeParameters.Count) { return new GenericReturnType(method.TypeParameters[type.GenericParameterPosition]); } return new GenericReturnType(new DefaultTypeParameter(method, type)); } } return new GenericReturnType(new DefaultTypeParameter(c, type)); } else { string name = type.FullName; if (name == null) throw new ApplicationException("type.FullName returned null. Type: " + type.ToString()); int typeParameterCount = 0; if (name.Length > 2) { if (name[name.Length - 2] == '`') { typeParameterCount = int.Parse(name[name.Length - 1].ToString()); name = name.Substring(0, name.Length - 2); } } if (name.IndexOf('+') > 0) { name = name.Replace('+', '.'); } if (!createLazyReturnType) { IClass c = pc.GetClass(name, typeParameterCount); if (c != null) return c.DefaultReturnType; // example where name is not found: pointers like System.Char* // or when the class is in a assembly that is not referenced } return new GetClassReturnType(pc, name, typeParameterCount); } }
private EcmaCil.TypeMeta EnqueueType(Type aTypeRef, object aSource, string aSourceType) { if (mLogEnabled) { LogMapPoint(aSource, aSourceType, aTypeRef); } List<Type> xTypeArgs = null; if (aTypeRef.IsArray) { var xQueuedArrayType = new QueuedArrayType(aTypeRef); EcmaCil.ArrayTypeMeta xArrayMeta; if (mArrayTypes.TryGetValue(xQueuedArrayType, out xArrayMeta)) { return xArrayMeta; } var xElemMeta = EnqueueType(aTypeRef.GetElementType(), aTypeRef, "Array element type"); xArrayMeta = new EcmaCil.ArrayTypeMeta { ElementType = xElemMeta }; mArrayTypes.Add(xQueuedArrayType, xArrayMeta); mQueue.Enqueue(xQueuedArrayType); return xArrayMeta; } if (aTypeRef.IsPointer) { var xQueuedPointerType = new QueuedPointerType(aTypeRef); EcmaCil.PointerTypeMeta xPointerMeta; if (mPointerTypes.TryGetValue(xQueuedPointerType, out xPointerMeta)) { return xPointerMeta; } var xElemMeta = EnqueueType(aTypeRef.GetElementType(), aTypeRef, "Array element type"); xPointerMeta = new EcmaCil.PointerTypeMeta { ElementType = xElemMeta }; mPointerTypes.Add(xQueuedPointerType, xPointerMeta); mQueue.Enqueue(xQueuedPointerType); return xPointerMeta; } if (aTypeRef.IsGenericType) { xTypeArgs = new List<Type>(aTypeRef.GetGenericArguments()); } var xQueuedType = new QueuedType(aTypeRef, (xTypeArgs == null ? null : xTypeArgs.ToArray())); EcmaCil.TypeMeta xTypeMeta; if (mTypes.TryGetValue(xQueuedType, out xTypeMeta)) { return xTypeMeta; } xTypeMeta = new EcmaCil.TypeMeta(); mTypeMetaToType.Add(xTypeMeta, aTypeRef); if (aTypeRef.BaseType != null) { xTypeMeta.BaseType = EnqueueType(aTypeRef.BaseType, aTypeRef, "Base type"); } mTypes.Add(xQueuedType, xTypeMeta); mQueue.Enqueue(xQueuedType); return xTypeMeta; }
public string GetKeyForType(Type type) { if (IsGenericCollection(type)) { return type.Namespace + "." + type.Name; } if (type.IsArray && !(type.GetElementType().IsValueType || type.GetElementType() == typeof (string))) { return "System.Array"; } return type.GetProxiedTypeFullName(); }
internal static object ConvertTo(Type type, string value, char separator) { if (!type.IsArray) { throw new ArgumentException("Not an array"); } var obj = value.Split(separator).Select(s => ConvertTo(type.GetElementType(), s)).ToArray(); var arr = Array.CreateInstance(type.GetElementType(), obj.Length); Array.Copy(obj, arr, obj.Length); return arr; }
public bool TryConvertTo(ITypeConverter root, TypeConversionContext context, Type convertTo, object value, out object result) { if (convertTo.IsArray) { var array = Array.CreateInstance(convertTo.GetElementType(), 1); var typedValue = root.ConvertTo(context, convertTo.GetElementType(), value); array.SetValue(typedValue, 0); result = array; return true; } result = null; return false; }
internal static object Revive(Type t, string name, string value) { if (t.IsArray == false && t.GetInterfaces().Contains(typeof(IList))) { var list = (IList) Activator.CreateInstance(t); // TODO - Maybe support custom delimiters via an attribute on the property // TODO - Maybe do a full parse of the value to check for quoted strings if (string.IsNullOrWhiteSpace(value) == false) { foreach (var element in value.Split(',')) { list.Add(Revive(t.GetGenericArguments()[0], name + "_element", element)); } } return list; } else if (t.IsArray) { var elements = value.Split(','); if (string.IsNullOrWhiteSpace(value) == false) { Array array = Array.CreateInstance(t.GetElementType(), elements.Length); for (int i = 0; i < array.Length; i++) { array.SetValue(Revive(t.GetElementType(), name + "[" + i + "]", elements[i]), i); } return array; } else { return Array.CreateInstance(t.GetElementType(), 0); } } else if (Revivers.ContainsKey(t)) { return Revivers[t].Invoke(name, value); } else if (System.ComponentModel.TypeDescriptor.GetConverter(t).CanConvertFrom(typeof(string))) { return System.ComponentModel.TypeDescriptor.GetConverter(t).ConvertFromString(value); } else { // Intentionally not an InvalidArgDefinitionException. Other internal code should call // CanRevive and this block should never be executed. throw new ArgumentException("Cannot revive type "+t.FullName+". Callers should be calling CanRevive before calling Revive()"); } }
private static Type GetElementType(Type targetType) { if (targetType.GetElementType() != null) { return targetType.GetElementType(); } var genericArgs = targetType.GetGenericArguments().FirstOrDefault(); if (genericArgs == null) { throw new NotSupportedException(string.Format("Cannot map to type '{0}' - try using List<T>, Type[] or other generic collection types.", targetType.Name)); } return genericArgs; }
public string this [Type type] { set { knownTypes.Add (type, value); } get { if (type.IsArray) { if (knownTypes.Contains (type.GetElementType ())) return (string) knownTypes [type.GetElementType ()] + "[]"; } else if (knownTypes.Contains (type)) return (string) knownTypes [type]; return FullNames ? type.FullName : type.Name; } }
private static string GetClrTypeFullNameForArray(Type type) { int arrayRank = type.GetArrayRank(); if (arrayRank == 1) { return string.Format(CultureInfo.InvariantCulture, "{0}{1}", new object[] { GetClrTypeFullName(type.GetElementType()), "[]" }); } StringBuilder builder = new StringBuilder(GetClrTypeFullName(type.GetElementType())).Append("["); for (int i = 1; i < arrayRank; i++) { builder.Append(","); } builder.Append("]"); return builder.ToString(); }
public GetTypeForm(Type currType, object data) { if (currType.GetElementType() != null) { m_currType = currType.GetElementType(); } else { m_currType = currType; } m_data = data; InitializeComponent(); }
private static void SubSnap(StringBuilder buffer, System.Type type, string name, object v) { buffer.Append(InternalNGDebug.DataSeparator); buffer.Append(name); buffer.Append("="); if (v == null) { buffer.Append("NULL"); } else if (type.IsPrimitive() == true || type == typeof(string) || type == typeof(decimal)) { if ('\0'.Equals(v) == true || "\0".Equals(v) == true) { buffer.Append("\\0"); } else { buffer.Append(v); } } else if (type.IsArray == true) { buffer.Append(type.GetElementType().Name + "[" + (v as System.Array).Length + "]"); } else if (typeof(IList).IsAssignableFrom(type) == true) { buffer.Append(type.Name + "<" + Utility.GetArraySubType(type).Name + ">[" + (v as IList).Count + "]"); } else { buffer.Append(v.ToString().Replace(InternalNGDebug.DataSeparator, InternalNGDebug.DataSeparatorReplace)); } }
internal static string GetCSharpName(Type t) { int num = 0; while (t.IsArray) { t = t.GetElementType(); num++; } StringBuilder sb = new StringBuilder(); sb.Append("global::"); string str = t.Namespace; if ((str != null) && (str.Length > 0)) { string[] strArray = str.Split(new char[] { '.' }); for (int j = 0; j < strArray.Length; j++) { EscapeKeywords(strArray[j], csharp, sb); sb.Append("."); } } Type[] parameters = (t.IsGenericType || t.ContainsGenericParameters) ? t.GetGenericArguments() : new Type[0]; GetCSharpName(t, parameters, 0, sb); for (int i = 0; i < num; i++) { sb.Append("[]"); } return sb.ToString(); }
private static string SimpleName(System.Type t) { if (t.IsByRef) { t = t.GetElementType(); } string tn = t.Name; switch (tn) { case "Single": return("float"); case "String": return("string"); case "Double": return("double"); case "Boolean": return("bool"); case "Int32": return("int"); case "Object": return(FullName(t)); default: tn = TypeDecl(t); tn = tn.Replace("System.Collections.Generic.", ""); tn = tn.Replace("System.Object", "object"); return(tn); } }
public static Type FindIEnumerable(Type seqType) { if (seqType == null || seqType == typeof(string)) return null; if (seqType.IsArray) return typeof(IEnumerable<>).MakeGenericType(seqType.GetElementType()); if (seqType.IsGenericType) { foreach (Type arg in seqType.GetGenericArguments()) { Type ienum = typeof(IEnumerable<>).MakeGenericType(arg); if (ienum.IsAssignableFrom(seqType)) { return ienum; } } } Type[] ifaces = seqType.GetInterfaces(); if (ifaces != null && ifaces.Length > 0) { foreach (Type iface in ifaces) { Type ienum = FindIEnumerable(iface); if (ienum != null) return ienum; } } if (seqType.BaseType != null && seqType.BaseType != typeof(object)) { return FindIEnumerable(seqType.BaseType); } return null; }
private static string TypeDecl(System.Type t) { if (t.IsGenericType) { string ret = GenericBaseName(t); string gs = ""; gs += "<"; System.Type[] types = t.GetGenericArguments(); for (int n = 0; n < types.Length; n++) { gs += SimpleName(types[n]); if (n < types.Length - 1) { gs += ","; } } gs += ">"; ret = Regex.Replace(ret, @"`\d+", gs); return(ret); } if (t.IsArray) { return(TypeDecl(t.GetElementType()) + "[]"); } else { return(RemoveRef(t.ToString(), false)); } }
private object ConvertArray(string[] items, Type destinationType, BindingContext context) { var elementType = destinationType.GetElementType(); if (elementType == null) { return null; } var converter = context.TypeConverters.Where(c => c.CanConvertTo(elementType)).FirstOrDefault(); if (converter == null) { return null; } var returnArray = items.Select(s => converter.Convert(s, elementType, context)); var genericCastMethod = this.enumerableCastMethod.MakeGenericMethod(new[] { elementType }); var generictoArrayMethod = this.enumerableToArrayMethod.MakeGenericMethod(new[] { elementType }); var castArray = genericCastMethod.Invoke(null, new object[] { returnArray }); return generictoArrayMethod.Invoke(null, new[] { castArray }); }
private static bool IsValid(Type type, TypeInfo typeInfo) { if (!ReferenceEquals(null, type)) { if (typeInfo.IsArray) { type = type.GetElementType(); } if (typeInfo.IsAnonymousType || type.IsAnonymousType()) { var properties = type.GetProperties().Select(x => x.Name).ToList(); var propertyNames = typeInfo.Properties.Select(x => x.Name).ToList(); var match = type.IsAnonymousType() && typeInfo.IsAnonymousType && properties.Count == propertyNames.Count && propertyNames.All(x => properties.Contains(x)); if (!match) { return false; } } return true; } return false; }
private static Type FindIEnumerable(Type seqType) { if (seqType == null || seqType == typeof(string)) return null; if (seqType.IsArray) return typeof(IEnumerable<>).MakeGenericType(seqType.GetElementType()); if (seqType.IsGenericType) foreach (var arg in seqType.GetGenericArguments()) { var ienum = typeof(IEnumerable<>).MakeGenericType(arg); if (ienum.IsAssignableFrom(seqType)) return ienum; } var ifaces = seqType.GetInterfaces(); if (ifaces != null) foreach (var iface in ifaces) { var ienum = FindIEnumerable(iface); if (ienum != null) return ienum; } if (seqType.BaseType != null && seqType.BaseType != typeof(object)) return FindIEnumerable(seqType.BaseType); return null; }
public LitJson.JsonData GetJson <T>() { LitJson.JsonData json = new LitJson.JsonData(); string[] lines = Lines; if (lines.Length > 1) { string[] columnNames = SplitWithDoubleQuote(lines[0], ','); // for UnitySerializer System.Type type = typeof(T); json["___i"] = type.FullName; if (type.IsArray) { json["count"] = lines.Length - 1; LitJson.JsonData array = new LitJson.JsonData(); json["contents"] = array; for (int i = 1; i < lines.Length; i++) { string[] values = SplitWithDoubleQuote(lines[i], ','); LitJson.JsonData aItem = new LitJson.JsonData(); // for UnitySerializer if (type.IsArray) { aItem["___i"] = type.GetElementType().FullName; } for (int v = 0; v < columnNames.Length; v++) { string val = values[v]; if (string.IsNullOrEmpty(val) == false) { aItem[columnNames[v]] = val; } } array.Add(aItem); } } else { string[] values = SplitWithDoubleQuote(lines[1], ','); for (int v = 0; v < columnNames.Length; v++) { string val = values[v]; if (string.IsNullOrEmpty(val) == false) { json[columnNames[v]] = val; } } } } // CLog.Log ( json.ToJson()); return(json); }
private static bool IsEnumType(System.Type t) { if (t.IsByRef) { t = t.GetElementType(); } return(t.IsEnum); }
private static bool IsPrimitiveType(System.Type t) { if (t.IsByRef) { t = t.GetElementType(); } return(t.IsPrimitive); }
public static Type GetValueType(FieldInfo fieldInfo) { Type referenceType = GetReferenceType(fieldInfo); if (referenceType.IsArray) { referenceType = referenceType.GetElementType(); } FieldInfo constantValueField = referenceType.GetField(ConstantValueName, NonPublicBindingsFlag); return(constantValueField.FieldType); }
System.Type GetFieldType() { System.Type type = fieldInfo.FieldType; if (type.IsArray) { type = type.GetElementType(); } else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>)) { type = type.GetGenericArguments()[0]; } return(type); }
void SetupLists() { _lists = new Dictionary <string, Editor_List>(); _asoLists = new Dictionary <string, Editor_ASOList>(); //Create new lists for each array property #region Create Lists from Properties SerializedProperty properties = serializedObject.GetIterator(); while (properties.NextVisible(true)) { if (properties.isArray && properties.propertyType != SerializedPropertyType.String) { //Debug.Log(properties.name); if (properties.name == "data") { continue; } System.Type type = AdvancedScriptableObjectUtility.GetSerializedPropertyType(properties); //Debug.Log(type); if (type != null) { if (type.GetElementType().IsSubclassOf(typeof(AdvancedScriptableObject))) { SerializedProperty asoPropCopy = properties.Copy(); if (!_asoLists.ContainsKey(asoPropCopy.name)) { _asoLists.Add(asoPropCopy.name, new Editor_ASOList(asoPropCopy)); } continue; } else { SerializedProperty propCopy = properties.Copy(); if (!_asoLists.ContainsKey(propCopy.name)) { _lists.Add(propCopy.name, new Editor_List(propCopy)); } continue; } } } } #endregion _bListsCreated = true; //Debug.Log(string.Format("List count:{0} ASOList count:{1}",_lists.Count,_asoLists.Count)); }
public static Type GetValueType(FieldInfo fieldInfo) { Type referenceType = GetReferenceType(fieldInfo); if (referenceType.IsArray) { referenceType = referenceType.GetElementType(); } else if (IsList(referenceType)) { referenceType = referenceType.GetGenericArguments()[0]; } FieldInfo constantValueField = referenceType.GetField(ConstantValueName, NonPublicBindingFlag); return(constantValueField.FieldType); }
private static bool IsAssignableFrom(System.Type to, System.Type from) { if (to.IsAssignableFrom(from)) { return(true); } else if (to.IsArray && to.GetElementType().IsAssignableFrom(from)) { return(true); } else if (from == typeof(Texture2D) && to == typeof(Sprite) || to.HasElementType && to.GetElementType() == typeof(Sprite)) { return(true); } return(false); }
/// <summary> /// Gets the type of the IList element. /// </summary> /// <returns> /// The IList element type if the supplied type is assignable from IList, otherwise <c>null</c>. /// </returns> /// <param name="type">An IList type.</param> public static System.Type GetIListElementType(System.Type type) { if (typeof(IList).IsAssignableFrom(type)) { if (type.IsArray) { return(type.GetElementType()); } else { return(type.GetGenericArguments()[0]); } } else { return(null); } }
string GetPropertyType(SerializedProperty prop) { string[] slices = prop.propertyPath.Split('.'); System.Type type = prop.serializedObject.targetObject.GetType(); for (int u = 0; u < slices.Length; u++) { if (slices[u] == "Array") { u++; //skips "data[x]" type = type.GetElementType(); //gets info on array elements } else { type = type.GetField(slices[u], BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance).FieldType; } } return(type.ToString()); }
/// <summary> /// Reads a value from the XML stream. /// </summary> private object ReadValue(XmlTextReader reader, System.Type datatype) { // read the datatype attribute. if (datatype == null || datatype == typeof(object)) { if (reader.MoveToAttribute(TYPE, Opc.Namespace.XML_SCHEMA_INSTANCE)) { datatype = ReadType(reader, reader.Value); } // default datatype is object. else { datatype = (reader.IsStartElement())?typeof(object[]):typeof(object); } } // get the period. if (reader.MoveToAttribute(PERIOD)) { m_period = (int)Opc.Convert.ChangeType(reader.Value, typeof(int)); } // get the sampling rate. if (reader.MoveToAttribute(SAMPLING_RATE)) { m_samplingRate = (int)Opc.Convert.ChangeType(reader.Value, typeof(int)); } // get the waveform. if (reader.MoveToAttribute(WAVEFORM)) { m_waveform = (int)Opc.Convert.ChangeType(reader.Value, typeof(int)); } reader.ReadStartElement(); // read a simple value. object value = null; if (!datatype.IsArray) { value = Opc.Convert.ChangeType(reader.ReadString(), datatype); } // read an array value. else { ArrayList values = new ArrayList(); while (reader.IsStartElement()) { values.Add(ReadValue(reader, datatype.GetElementType())); } value = values.ToArray(datatype.GetElementType()); } // read end element. reader.ReadEndElement(); // return value. return(value); }
/// <summary> /// Initializes an item value object with the item properties. /// </summary> private void GetDefaultValues(OpcDa::ItemValue[] items, bool valuesOnly) { try { // get item value properties. OpcDa::ItemPropertyCollection[] propertyLists = m_server.GetProperties( items, new OpcDa::PropertyID[] { OpcDa::Property.DATATYPE, OpcDa::Property.QUALITY, OpcDa::Property.TIMESTAMP, OpcDa::Property.VALUE }, true); // update item values. for (int ii = 0; ii < items.Length; ii++) { // ignore errors for failures for individual items. if (propertyLists[ii].ResultID.Failed()) { continue; } // set a default value based on the data type. object defaultValue = propertyLists[ii][3].Value; if (defaultValue == null) { System.Type type = (System.Type)propertyLists[ii][0].Value; System.Type baseType = (type.IsArray) ? type.GetElementType() : type; if (baseType == typeof(string)) { defaultValue = ""; } if (baseType == typeof(DateTime)) { defaultValue = System.DateTime.Now; } if (baseType == typeof(object)) { defaultValue = ""; } defaultValue = Opc.Convert.ChangeType(defaultValue, baseType); //Opc.Convert to a three element array. if (type.IsArray) { defaultValue = new object[] { defaultValue, defaultValue, defaultValue }; defaultValue = Opc.Convert.ChangeType(defaultValue, type); } } // update the object. items[ii].Value = defaultValue; items[ii].Quality = (OpcDa::Quality)propertyLists[ii][1].Value; items[ii].Timestamp = (DateTime)propertyLists[ii][2].Value; // set the quality/timestamp exists flags. items[ii].QualitySpecified = !valuesOnly; items[ii].TimestampSpecified = !valuesOnly; } } catch (Exception ex) { AssemblyTraceEvent.Tracer.TraceEvent(TraceEventType.Information, 309, this.GetType().Name + ".GetDefaultValues", Resources.ItemValueListEditCtrl_property_error + ex.Message); } }
TypeReference InferType(IReferenceMap referenceMap, Type type) { type = type ?? throw new ArgumentNullException(nameof(type)); JsiiClassAttribute classAttribute = ReflectionUtils.GetClassAttribute(type); if (classAttribute != null) { return(new TypeReference(classAttribute.FullyQualifiedName)); } JsiiEnumAttribute enumAttribute = type.GetCustomAttribute <JsiiEnumAttribute>(); if (enumAttribute != null) { return(new TypeReference(enumAttribute.FullyQualifiedName)); } if (typeof(string).IsAssignableFrom(type)) { return(new TypeReference(primitive: PrimitiveType.String)); } if (typeof(bool).IsAssignableFrom(type)) { return(new TypeReference(primitive: PrimitiveType.Boolean)); } if (IsNumeric(type)) { return(new TypeReference(primitive: PrimitiveType.Number)); } if (typeof(DateTime).IsAssignableFrom(type)) { return(new TypeReference(primitive: PrimitiveType.Date)); } if (typeof(JObject).IsAssignableFrom(type) || typeof(JArray).IsAssignableFrom(type)) { return(new TypeReference(primitive: PrimitiveType.Json)); } if (type.IsArray) { return(new TypeReference ( collection: new CollectionTypeReference ( kind: CollectionKind.Array, elementType: typeof(Object) == type.GetElementType() ? new TypeReference(primitive: PrimitiveType.Any) : InferType(referenceMap, type.GetElementType()) ) )); } Type dictionaryInterface = type.GetInterfaces() .FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IDictionary <,>)); if (dictionaryInterface != null) { if (!typeof(string).IsAssignableFrom(dictionaryInterface.GetGenericArguments()[0])) { throw new ArgumentException("All dictionaries must have string keys", nameof(type)); } Type elementType = dictionaryInterface.GetGenericArguments()[1]; return(new TypeReference ( collection: new CollectionTypeReference ( kind: CollectionKind.Map, elementType: typeof(Object) == elementType ? new TypeReference(primitive: PrimitiveType.Any) : InferType(referenceMap, elementType) ) )); } throw new ArgumentException($"Could not infer JSII type for .NET type '{type.Name}'", nameof(type)); }
public static object ReadClass(int slotNum, List <string> classes, List <UnityEngine.Object> objects, List <float> floats, List <object> references) { //cheking if this object was already loaded for (int i = references.Count; i < classes.Count; i++) { references.Add(null); //references count should be equal to classes length } if (references[slotNum] != null) { return(references[slotNum]); } object obj = null; StringReader reader = new StringReader(classes[slotNum]); //reading header string header = reader.ReadLine(); header = header.Substring(1, header.Length - 2); //getting the array length int arrayLength = 0; if (header.Contains(" length=")) { string[] headerMembers = header.Split(' '); arrayLength = (int)headerMembers[1].Parse(typeof(int)); header = headerMembers[0]; } //finding object type System.Type objType = GetStandardAssembliesType(header); if (objType == null) { Debug.LogError("Could not load " + header + " as this type does not exists anymore"); return(null); } System.Type elementType = objType.IsArray? objType.GetElementType() : null; //creating object if (objType.IsArray) { obj = Activator.CreateInstance(objType, arrayLength); } else { obj = Activator.CreateInstance(objType); } references[slotNum] = obj; //reading values List <Value> values = new List <Value>(); while (true) { string line = reader.ReadLine(); if (line == null || line.StartsWith("</")) { break; } //if (line.StartsWith("\t")) line = line.Remove(0,1); //removing tab if any line = line.Substring(2, line.Length - 4); //removing < and /> string[] lineMembers = line.Split(' ', ','); Value val = new Value(); //name val.name = lineMembers[0]; //type string typeName = lineMembers[1].Remove(0, 5); val.type = GetStandardAssembliesType(typeName); if (val.type == null) { Debug.LogError("Could not load " + typeName + " as this type does not exists anymore"); return(null); } //object: quick array if (val.type.IsArray && val.name == "items") { if (val.type == typeof(float[])) { int start = (int)lineMembers[2].Parse(typeof(int)); for (int i = start; i < start + arrayLength; i++) { values.Add(new Value() { name = "item", type = elementType, obj = floats[i] }); } } //class /*if (lineMembers[2].StartsWith("link")) * { * for (int i=2; i<lineMembers.Length; i++) * values.Add( new Value() { name="item", type=elementType, obj=ReadClass( (int)lineMembers[i].Parse(typeof(int)), classes, objects, floats, references) } ); * }*/ //primitives else { for (int i = 2; i < lineMembers.Length; i++) { values.Add(new Value() { name = "item", type = elementType, obj = lineMembers[i].Parse(elementType) }); } } } //object: other else { //null if (lineMembers[2] == "null") { val.obj = null; } //custom struct else if (typeof(IStruct).IsAssignableFrom(val.type)) { val.obj = Activator.CreateInstance(val.type); ((IStruct)val.obj).Decode(lineMembers); } //custom struct with links else if (typeof(IStructLink).IsAssignableFrom(val.type)) { Func <int, object> readClassFn = delegate(int link) { return(ReadClass(link, classes, objects, floats, references)); }; val.obj = Activator.CreateInstance(val.type); ((IStructLink)val.obj).Decode(lineMembers, readClassFn); } //class else if (lineMembers[2].StartsWith("link")) { //val.obj = int.Parse(lineMembers[2].Remove(0,5)); //postporning reading the class until the object is created, storing link val.obj = ReadClass(int.Parse(lineMembers[2].Remove(0, 5)), classes, objects, floats, references); } //primitive else if (val.type.IsPrimitive) { val.obj = lineMembers[2].Parse(val.type); } //unity Object else if (val.type.IsSubclassOf(typeof(UnityEngine.Object))) { val.obj = objects[(int)lineMembers[2].Parse(typeof(int))]; } //string else if (val.type == typeof(string)) { string str = (string)lineMembers[2].Parse(val.type); str = str.Replace("\\n", "\n"); str = str.Replace("\\_", " "); val.obj = str; } //Vector2 else if (val.type == typeof(Vector2)) { val.obj = new Vector2((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float))); } //{ // int n = (int)lineMembers[2].Parse(typeof(int)); // val.obj = new Vector2(floats[n], floats[n+1]); //} //Vector3 else if (val.type == typeof(Vector3)) { val.obj = new Vector3((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float)), (float)lineMembers[4].Parse(typeof(float))); } //{ // int n = (int)lineMembers[2].Parse(typeof(int)); // val.obj = new Vector3(floats[n], floats[n+1], floats[n+2]); //} //Rect else if (val.type == typeof(Rect)) { val.obj = new Rect((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float)), (float)lineMembers[4].Parse(typeof(float)), (float)lineMembers[5].Parse(typeof(float))); } //{ // int n = (int)lineMembers[2].Parse(typeof(int)); // val.obj = new Rect(floats[n], floats[n+1], floats[n+2], floats[n+3]); //} //Color else if (val.type == typeof(Color)) { val.obj = new Color((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float)), (float)lineMembers[4].Parse(typeof(float)), (float)lineMembers[5].Parse(typeof(float))); } //Vector4 else if (val.type == typeof(Vector4)) { val.obj = new Vector4((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float)), (float)lineMembers[4].Parse(typeof(float)), (float)lineMembers[5].Parse(typeof(float))); } //Quaternion else if (val.type == typeof(Quaternion)) { val.obj = new Quaternion((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float)), (float)lineMembers[4].Parse(typeof(float)), (float)lineMembers[5].Parse(typeof(float))); } //Quaternion else if (val.type == typeof(Keyframe)) { Keyframe k = new Keyframe((float)lineMembers[2].Parse(typeof(float)), (float)lineMembers[3].Parse(typeof(float)), (float)lineMembers[4].Parse(typeof(float)), (float)lineMembers[5].Parse(typeof(float))); k.tangentMode = (int)lineMembers[6].Parse(typeof(int)); val.obj = k; } //enum else if (val.type.IsEnum) { val.obj = Enum.ToObject(val.type, (int)lineMembers[2].Parse(typeof(int))); } values.Add(val); } } //reading the links (after the object is created and stored in references) /*int valuesCount = values.Count; * for (int i=0; i<valuesCount; i++) * if (values[i].link) * { * Value val = values[i]; * * int valSlotNum = (int)values[i].obj; * if (valSlotNum >= 0) val.obj = ReadClass((int)values[i].obj, classes, objects, references); * else val.obj = null; //TODO checking if link -1 doesntreally needed as the null is checked before class * * values[i] = val; * }*/ //filling object int valuesCount = values.Count; if (objType.IsArray) { Array array = (Array)obj; for (int i = 0; i < array.Length; i++) { array.SetValue(values[i].obj, i); } } else { foreach (FieldInfo field in objType.UsableFields()) { string fieldName = field.Name; Type fieldType = field.FieldType; for (int i = 0; i < valuesCount; i++) { if (values[i].name == fieldName && values[i].type == fieldType) { field.SetValue(obj, values[i].obj); } } } foreach (PropertyInfo prop in objType.UsableProperties()) { string propName = prop.Name; Type propType = prop.PropertyType; for (int i = 0; i < valuesCount; i++) { if (values[i].name == propName && values[i].type == propType) { prop.SetValue(obj, values[i].obj, null); } } } } return(obj); }
public int Store(object obj, bool writeProperties = true) { //storing nulls to -1 if (obj == null) { return(-1); } //if this object already added returning it's num int entitiesCount = entities.Count; for (int i = 0; i < entitiesCount; i++) { if (obj == entities[i].obj) { return(i); } } //creating entity SerializedObject entity = new SerializedObject(); System.Type objType = obj.GetType(); entity.typeName = objType.AssemblyQualifiedName.ToString(); entity.obj = obj; //adding entity to list before storing other objs entities.Add(entity); int result = entities.Count - 1; //writing arrays if (objType.IsArray) { Array array = (Array)obj; System.Type elementType = objType.GetElementType(); entity.AddValues(elementType, array, this); //for (int i=0;i<array.Length;i++) entity.AddValue(elementType, array.GetValue(i), "", this); return(result); } //writing fields FieldInfo[] fields = objType.GetFields(BindingFlags.Public | BindingFlags.Instance); //BindingFlags.NonPublic - does not work in web player for (int i = 0; i < fields.Length; i++) { FieldInfo field = fields[i]; if (field.IsLiteral) { continue; //leaving constant fields blank } if (field.FieldType.IsPointer) { continue; //skipping pointers (they make unity crash. Maybe require unsafe) } if (field.IsNotSerialized) { continue; } entity.AddValue(field.FieldType, field.GetValue(obj), field.Name, this); } //writing properties if (writeProperties) { PropertyInfo[] properties = objType.GetProperties(BindingFlags.Public | BindingFlags.Instance); for (int i = 0; i < properties.Length; i++) { PropertyInfo prop = properties[i]; if (!prop.CanWrite) { continue; } if (prop.Name == "Item") { continue; //ignoring this[x] } entity.AddValue(prop.PropertyType, prop.GetValue(obj, null), prop.Name, this); } } return(result); }
private object ConvertToClrTypeImpl(Value wireValue, System.Type targetClrType, SpannerConversionOptions options) { //If the wireValue itself is assignable to the target type, just return it //This covers both typeof(Value) and typeof(object). if (wireValue == null || targetClrType == null || targetClrType == typeof(Value)) { return(wireValue); } if (wireValue.KindCase == Value.KindOneofCase.StructValue) { throw new InvalidOperationException($"google.protobuf.Struct values are invalid in Spanner"); } // targetClrType should be one of the values returned by DefaultClrType if (targetClrType == typeof(bool)) { switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(default(bool)); case Value.KindOneofCase.StringValue: if (TypeCode == TypeCode.Int64) { return(Convert.ToBoolean(Convert.ToInt64(wireValue.StringValue, InvariantCulture))); } return(Convert.ToBoolean(wireValue.StringValue)); case Value.KindOneofCase.BoolValue: return(wireValue.BoolValue); case Value.KindOneofCase.NumberValue: return(Convert.ToBoolean(wireValue.NumberValue)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(char)) { switch (wireValue.KindCase) { case Value.KindOneofCase.BoolValue: return(Convert.ToChar(wireValue.BoolValue)); case Value.KindOneofCase.NumberValue: return(Convert.ToChar(wireValue.NumberValue)); case Value.KindOneofCase.NullValue: return(default(char)); case Value.KindOneofCase.StringValue: if (TypeCode == TypeCode.Int64) { return(Convert.ToChar(Convert.ToInt64(wireValue.StringValue, InvariantCulture))); } return(Convert.ToChar(wireValue.StringValue)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(long)) { switch (wireValue.KindCase) { case Value.KindOneofCase.BoolValue: return(Convert.ToInt64(wireValue.BoolValue)); case Value.KindOneofCase.NumberValue: return(Convert.ToInt64(wireValue.NumberValue)); case Value.KindOneofCase.NullValue: return(default(long)); case Value.KindOneofCase.StringValue: return(Convert.ToInt64(wireValue.StringValue, InvariantCulture)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(ulong)) { switch (wireValue.KindCase) { case Value.KindOneofCase.BoolValue: return(Convert.ToUInt64(wireValue.BoolValue)); case Value.KindOneofCase.NumberValue: return(Convert.ToUInt64(wireValue.NumberValue)); case Value.KindOneofCase.NullValue: return(default(ulong)); case Value.KindOneofCase.StringValue: return(Convert.ToUInt64(wireValue.StringValue, InvariantCulture)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(decimal)) { switch (wireValue.KindCase) { case Value.KindOneofCase.BoolValue: return(Convert.ToDecimal(wireValue.BoolValue)); case Value.KindOneofCase.NumberValue: return(Convert.ToDecimal(wireValue.NumberValue)); case Value.KindOneofCase.NullValue: return(default(decimal)); case Value.KindOneofCase.StringValue: return(Convert.ToDecimal(wireValue.StringValue, InvariantCulture)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(double)) { switch (wireValue.KindCase) { case Value.KindOneofCase.BoolValue: return(Convert.ToDouble(wireValue.BoolValue)); case Value.KindOneofCase.NullValue: return(default(double)); case Value.KindOneofCase.NumberValue: return(wireValue.NumberValue); case Value.KindOneofCase.StringValue: if (string.Compare(wireValue.StringValue, "NaN", StringComparison.OrdinalIgnoreCase) == 0) { return(double.NaN); } if (string.Compare(wireValue.StringValue, "Infinity", StringComparison.OrdinalIgnoreCase) == 0) { return(double.PositiveInfinity); } if (string.Compare(wireValue.StringValue, "-Infinity", StringComparison.OrdinalIgnoreCase) == 0) { return(double.NegativeInfinity); } return(Convert.ToDouble(wireValue.StringValue, InvariantCulture)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(DateTime)) { switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(null); case Value.KindOneofCase.StringValue: return(XmlConvert.ToDateTime(wireValue.StringValue, XmlDateTimeSerializationMode.Utc)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(Timestamp)) { switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(null); case Value.KindOneofCase.StringValue: return(Protobuf.WellKnownTypes.Timestamp.Parser.ParseJson(wireValue.StringValue)); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType == typeof(string)) { switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(null); case Value.KindOneofCase.NumberValue: return(wireValue.NumberValue.ToString(InvariantCulture)); case Value.KindOneofCase.StringValue: return(wireValue.StringValue); case Value.KindOneofCase.BoolValue: return(wireValue.BoolValue.ToString()); default: return(wireValue.ToString()); } } if (targetClrType == typeof(byte[])) { switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(null); case Value.KindOneofCase.StringValue: return(Convert.FromBase64String(wireValue.StringValue)); default: throw new ArgumentOutOfRangeException(); } } if (targetClrType == typeof(SpannerStruct)) { if (TypeCode != TypeCode.Struct) { throw new ArgumentException( $"{targetClrType.FullName} can only be used for struct results"); } if (wireValue.KindCase != Value.KindOneofCase.ListValue) { throw new ArgumentException( $"Invalid conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } var values = wireValue.ListValue.Values; // StructFields will definitely be non-null, as we can only construct SpannerDbTypes of structs // by passing them fields. var ret = new SpannerStruct(); if (StructFields.Count != values.Count) { throw new InvalidOperationException( $"Incorrect number of struct fields. SpannerDbType has {StructFields.Count}; list has {values.Count}"); } // Could use Zip, but this is probably simpler. for (int i = 0; i < values.Count; i++) { var field = StructFields[i]; ret.Add(field.Name, field.Type, field.Type.ConvertToClrType(values[i], typeof(object), options, topLevel: false)); } return(ret); } // TODO: Do we still want to support this? if (typeof(IDictionary).IsAssignableFrom(targetClrType)) { if (targetClrType == typeof(IDictionary)) { // Default type depends on whether it's a struct or not. targetClrType = TypeCode == TypeCode.Struct ? typeof(Dictionary <string, object>) : typeof(Dictionary <int, object>); } //a bit of recursion here... IDictionary dictionary = (IDictionary)Activator.CreateInstance(targetClrType); var itemType = targetClrType.GetGenericArguments().Skip(1).FirstOrDefault() ?? typeof(object); switch (wireValue.KindCase) { case Value.KindOneofCase.ListValue: if (TypeCode == TypeCode.Struct) { for (int i = 0; i < StructFields.Count; i++) { var elementValue = wireValue.ListValue.Values[i]; var field = StructFields[i]; dictionary[field.Name] = field.Type.ConvertToClrType(elementValue, itemType, options, topLevel: false); } } else { var i = 0; foreach (var listItemValue in wireValue.ListValue.Values) { dictionary[i] = ArrayElementType.ConvertToClrType(listItemValue, itemType, options, topLevel: false); i++; } } return(dictionary); default: throw new ArgumentException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (targetClrType.IsArray) { switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(null); case Value.KindOneofCase.ListValue: var newArray = Array.CreateInstance( targetClrType.GetElementType(), wireValue.ListValue.Values.Count); var i = 0; foreach (var obj in wireValue.ListValue.Values.Select( x => ArrayElementType.ConvertToClrType(x, targetClrType.GetElementType(), options, topLevel: false))) { newArray.SetValue(obj, i); i++; } return(newArray); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } if (typeof(IList).IsAssignableFrom(targetClrType)) { if (targetClrType == typeof(IList)) { targetClrType = typeof(List <object>); } switch (wireValue.KindCase) { case Value.KindOneofCase.NullValue: return(null); case Value.KindOneofCase.ListValue: var newList = (IList)Activator.CreateInstance(targetClrType); var itemType = targetClrType.GetGenericArguments().FirstOrDefault() ?? typeof(object); foreach (var obj in wireValue.ListValue.Values.Select( x => ArrayElementType.ConvertToClrType(x, itemType, options, topLevel: false))) { newList.Add(obj); } return(newList); default: throw new InvalidOperationException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); } } throw new ArgumentException( $"Invalid Type conversion from {wireValue.KindCase} to {targetClrType.FullName}"); }
private Type ImportImpl(System.Type type) { if (type.Assembly == typeof(IKVM.Reflection.Type).Assembly) { throw new ArgumentException("Did you really want to import " + type.FullName + "?"); } if (type.HasElementType) { if (type.IsArray) { if (type.Name.EndsWith("[]")) { return(Import(type.GetElementType()).MakeArrayType()); } else { return(Import(type.GetElementType()).MakeArrayType(type.GetArrayRank())); } } else if (type.IsByRef) { return(Import(type.GetElementType()).MakeByRefType()); } else if (type.IsPointer) { return(Import(type.GetElementType()).MakePointerType()); } else { throw new InvalidOperationException(); } } else if (type.IsGenericParameter) { if (type.DeclaringMethod != null) { throw new NotImplementedException(); } else { return(Import(type.DeclaringType).GetGenericArguments()[type.GenericParameterPosition]); } } else if (type.IsGenericType && !type.IsGenericTypeDefinition) { System.Type[] args = type.GetGenericArguments(); Type[] importedArgs = new Type[args.Length]; for (int i = 0; i < args.Length; i++) { importedArgs[i] = Import(args[i]); } return(Import(type.GetGenericTypeDefinition()).MakeGenericType(importedArgs)); } else if (type.Assembly == typeof(object).Assembly) { // make sure mscorlib types always end up in our mscorlib return(ResolveType(Mscorlib, type.FullName)); } else { // FXBUG we parse the FullName here, because type.Namespace and type.Name are both broken on the CLR return(ResolveType(Import(type.Assembly), type.FullName)); } }
private Type ImportImpl(System.Type type) { if (type.Assembly == typeof(IKVM.Reflection.Type).Assembly) { throw new ArgumentException("Did you really want to import " + type.FullName + "?"); } if (type.HasElementType) { if (type.IsArray) { if (type.Name.EndsWith("[]")) { return(Import(type.GetElementType()).MakeArrayType()); } else { return(Import(type.GetElementType()).MakeArrayType(type.GetArrayRank())); } } else if (type.IsByRef) { return(Import(type.GetElementType()).MakeByRefType()); } else if (type.IsPointer) { return(Import(type.GetElementType()).MakePointerType()); } else { throw new InvalidOperationException(); } } else if (type.IsGenericParameter) { if (type.DeclaringMethod != null) { throw new NotImplementedException(); } else { return(Import(type.DeclaringType).GetGenericArguments()[type.GenericParameterPosition]); } } else if (type.IsGenericType && !type.IsGenericTypeDefinition) { System.Type[] args = type.GetGenericArguments(); Type[] importedArgs = new Type[args.Length]; for (int i = 0; i < args.Length; i++) { importedArgs[i] = Import(args[i]); } return(Import(type.GetGenericTypeDefinition()).MakeGenericType(importedArgs)); } else if (type.IsNested) { // note that we can't pass in the namespace here, because .NET's Type.Namespace implementation is broken for nested types // (it returns the namespace of the declaring type) return(Import(type.DeclaringType).ResolveNestedType(new TypeName(null, type.Name))); } else if (type.Assembly == typeof(object).Assembly) { // make sure mscorlib types always end up in our mscorlib return(Mscorlib.ResolveType(new TypeName(type.Namespace, type.Name))); } else { return(Import(type.Assembly).ResolveType(new TypeName(type.Namespace, type.Name))); } }
public static object Load(System.Type type, string text, object oldValue) { if (type == null) { return(null); } if (type.IsPrimitive) { if (string.IsNullOrEmpty(text)) { try { return(Activator.CreateInstance(type)); } catch (MissingMethodException) { Debug.LogError(type.Name + " Doesn't seem to have a default constructor"); throw; } } return(Convert.ChangeType(text, type, CultureInfo.InvariantCulture)); } else if (typeof(UnityEngine.Object).IsAssignableFrom(type)) { object obj = new ObjectWrapper(); EditorJsonUtility.FromJsonOverwrite(text, obj); return(((ObjectWrapper)obj).obj); } else if (type.IsAssignableFrom(typeof(AnimationCurve))) { AnimCurveWrapper sac = new AnimCurveWrapper(); JsonUtility.FromJsonOverwrite(text, sac); AnimationCurve curve = oldValue != null ? (AnimationCurve)oldValue : new AnimationCurve(); if (sac.frames != null) { Keyframe[] keys = new UnityEngine.Keyframe[sac.frames.Length]; for (int i = 0; i < sac.frames.Length; ++i) { keys[i].time = sac.frames[i].time; keys[i].value = sac.frames[i].value; keys[i].inTangent = sac.frames[i].inTangent; keys[i].outTangent = sac.frames[i].outTangent; if (sac.version == 1) { AnimationUtility.SetKeyLeftTangentMode(ref keys[i], sac.frames[i].leftTangentMode); AnimationUtility.SetKeyRightTangentMode(ref keys[i], sac.frames[i].rightTangentMode); AnimationUtility.SetKeyBroken(ref keys[i], sac.frames[i].broken); } else { AnimationUtility.SetKeyLeftTangentMode(ref keys[i], (TangentMode)((sac.frames[i].tangentMode & kLeftTangentMask) >> 1)); AnimationUtility.SetKeyRightTangentMode(ref keys[i], (TangentMode)((sac.frames[i].tangentMode & kRightTangentMask) >> 5)); AnimationUtility.SetKeyBroken(ref keys[i], (sac.frames[i].tangentMode & kBrokenMask) != 0); } } curve.keys = keys; curve.preWrapMode = sac.preWrapMode; curve.postWrapMode = sac.postWrapMode; } return(curve); } else if (type.IsAssignableFrom(typeof(Gradient))) { GradientWrapper gw = new GradientWrapper(); Gradient gradient = oldValue != null ? (Gradient)oldValue : new Gradient(); JsonUtility.FromJsonOverwrite(text, gw); gradient.mode = gw.gradientMode; GradientColorKey[] colorKeys = null; if (gw.colorKeys != null) { colorKeys = new GradientColorKey[gw.colorKeys.Length]; for (int i = 0; i < gw.colorKeys.Length; ++i) { colorKeys[i].color = gw.colorKeys[i].color; colorKeys[i].time = gw.colorKeys[i].time; } } else { colorKeys = new GradientColorKey[0]; } GradientAlphaKey[] alphaKeys = null; if (gw.alphaKeys != null) { alphaKeys = new GradientAlphaKey[gw.alphaKeys.Length]; for (int i = 0; i < gw.alphaKeys.Length; ++i) { alphaKeys[i].alpha = gw.alphaKeys[i].alpha; alphaKeys[i].time = gw.alphaKeys[i].time; } } else { alphaKeys = new GradientAlphaKey[0]; } gradient.SetKeys(colorKeys, alphaKeys); return(gradient); } else if (type == typeof(string)) { if (string.IsNullOrEmpty(text)) { return(""); } return(text.Substring(1, text.Length - 2).Replace("\\\"", "\"")); } else if (type == typeof(SerializableType)) { var obj = new SerializableType(text.Substring(1, text.Length - 2)); return(obj); } else if (type.IsArrayOrList()) { List <string> elements = ParseArray(text); if (elements == null) { return(null); } if (type.IsArray) { int listCount = elements.Count; Array arrayObj = (Array)Activator.CreateInstance(type, new object[] { listCount }); for (int index = 0; index < listCount; index++) { arrayObj.SetValue(Load(type.GetElementType(), elements[index], null), index); } return(arrayObj); } else //List { int listCount = elements.Count; IList listObj = (IList)Activator.CreateInstance(type, new object[0]); for (int index = 0; index < listCount; index++) { listObj.Add(Load(type.GetElementType(), elements[index], null)); } return(listObj); } } else { try { object obj = Activator.CreateInstance(type); EditorJsonUtility.FromJsonOverwrite(text, obj); return(obj); } catch (MissingMethodException) { Debug.LogError(type.Name + " Doesn't seem to have a default constructor"); throw; } } }
public static object MakeSimpleDefaultEditor(object ob, System.Type t, string fname, object par) { string name = FriendlyString(fname); if (t == typeof(int)) { return(EditorGUILayout.IntField(name, (int)ob)); } else if (t == typeof(float)) { return(EditorGUILayout.FloatField(name, (float)ob)); } else if (t == typeof(bool)) { return(EditorGUILayout.Toggle(name, (bool)ob)); } else if (t == typeof(string)) { return(EditorGUILayout.TextField(name, (string)ob)); } else if (t == typeof(AnimationCurve)) { return(EditorGUILayout.CurveField(name, (AnimationCurve)ob)); } else if (t == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(name, (Vector3)ob)); } else if (t == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(name, (Vector2)ob)); } else if (t == typeof(Vector4)) { return(EditorGUILayout.Vector4Field(name, (Vector4)ob)); } else if (t == typeof(UnityEngine.GameObject)) { return(EditorGUILayout.ObjectField(name, (Object)ob, t, true)); } else if (t.IsSubclassOf(typeof(UnityEngine.Component))) { FieldInfo fedit = null; if (editorClass != null) { fedit = editorClass.GetField(t.ToString().ToLower() + "Edit"); } if (fedit == null) { return(EditorGUILayout.ObjectField(name, (Object)ob, t, true)); } else { List <ComponentEdit> a = fedit.GetValue(null) as List <ComponentEdit>; ComponentEdit ce = null; for (int i = 0; i < a.Count; i++) { if (a[i].com == ob) { ce = a[i]; break; } } if (ce == null) { ce = new ComponentEdit(); a.Add(ce); } EditorGUILayout.LabelField(name); EditorGUI.indentLevel++; EditorGUILayout.BeginHorizontal(); ob = EditorGUILayout.ObjectField((Object)ob, t, true, GUILayout.Width(150)); if (GUILayout.Button("New", GUILayout.Width(50))) { GameObject to = Selection.activeGameObject; GameObject g = GameObject.Find(t + "s"); if (g == null) { g = new GameObject(t + "s"); } GameObject go = new GameObject(to.name + "-" + par.GetType() + "-" + t); go.transform.parent = g.transform; go.transform.position = to.transform.position; ob = go.AddComponent(t); } if (GUILayout.Button("Sel", GUILayout.Width(50))) { Selection.activeGameObject = ((Component)ob).gameObject; } if (GUILayout.Button((ce.show?"De":"") + "Show", GUILayout.Width(70))) { ce.show = !ce.show; EditorUtility.SetDirty(ob as Object); } if (GUILayout.Button((ce.edit?"De":"") + "Edit", GUILayout.Width(70))) { ce.edit = !ce.edit; } EditorGUILayout.EndHorizontal(); EditorGUI.indentLevel--; return(ce.com = ob as Component); } } else if (t == typeof(LayerMask)) { return((LayerMask)(1 << EditorGUILayout.LayerField(name, ((LayerMask)ob).value))); } else if (t.IsArray) { System.Array a = (System.Array)ob; EditorGUILayout.BeginHorizontal(); EditorGUILayout.LabelField(name, GUILayout.Width(100)); System.Type et = t.GetElementType(); FieldInfo ft = typeof(Util).GetField("type" + et.ToString(), BindingFlags.Public | BindingFlags.Static); FieldInfo fit = typeof(Util).GetField("it" + et.ToString(), BindingFlags.NonPublic | BindingFlags.Static); List <string> st = null; int it = -1; if (et.IsAbstract) { st = ft.GetValue(null) as List <string>; it = (int)fit.GetValue(null); it = EditorGUILayout.Popup(it, st.ToArray()); fit.SetValue(null, it); } FieldInfo fsoa = null; List <string> soa = null; if (typeof(ScriptableObject).IsAssignableFrom(et)) { fsoa = par.GetType().GetField(name + "Asset", BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase); soa = fsoa.GetValue(par) as List <string>; } if (GUILayout.Button("New", GUILayout.Width(50))) { System.Array ta = System.Array.CreateInstance(et, a.Length + 1); for (int i = 0; i < a.Length; i++) { ta.SetValue(a.GetValue(i), i); } object tob = null; System.Type eet = et; if (et.IsAbstract) { eet = typeof(Util).Assembly.GetType(st[it]); } if (typeof(ScriptableObject).IsAssignableFrom(eet)) { string sos = SOInstance(eet); tob = AssetDatabase.LoadAllAssetsAtPath(sos)[0]; soa.Add(sos); } else { tob = System.Activator.CreateInstance(eet); } ta.SetValue(tob, a.Length); return(ta); } if (GUILayout.Button("Clear", GUILayout.Width(50))) { System.Array ta = System.Array.CreateInstance(et, 0); if (soa != null) { foreach (string s in soa) { AssetDatabase.DeleteAsset(s); } soa.Clear(); } return(ta); } EditorGUILayout.EndHorizontal(); EditorGUI.indentLevel++; int oi = -1; foreach (object tob in a) { oi++; string ename = tob.GetType().ToString(); FieldInfo no = tob.GetType().GetField("name", BindingFlags.Instance | BindingFlags.Public); if (no != null) { ename = (string)no.GetValue(tob); } string efname = ename; ename = FriendlyString(ename); bool simple = (et.IsValueType || et == typeof(string) || et == typeof(UnityEngine.GameObject) || et == typeof(UnityEngine.Component)); bool bfo = true; EditorGUILayout.BeginHorizontal(); if (simple) { object tob1 = MakeSimpleDefaultEditor(tob, et, efname, ob); if (tob1 != null || !tob1.Equals(tob)) { if (et.IsSubclassOf(typeof(Object))) { Undo.RegisterUndo((Object)ob, ename); } a.SetValue(tob1, oi); } } else { string sename = ename; if (typeof(ScriptableObject).IsAssignableFrom(et)) { string ssoa = soa[oi]; ssoa = ssoa.Substring(ssoa.LastIndexOf("/") + 1); sename += "-" + ssoa; } FieldInfo fo = tob.GetType().GetField("foldout", BindingFlags.Instance | BindingFlags.Public); if (fo != null) { bfo = (bool)fo.GetValue(tob); bfo = EditorGUILayout.Foldout(bfo, sename); fo.SetValue(tob, bfo); } else { EditorGUILayout.LabelField(sename); } } if (GUILayout.Button("X", GUILayout.Width(30))) { System.Array ta = System.Array.CreateInstance(et, a.Length - 1); for (int i = 0, j = 0; i < a.Length; i++) { if (a.GetValue(i) != tob) { ta.SetValue(a.GetValue(i), j++); } } if (soa != null) { AssetDatabase.DeleteAsset(soa[oi]); soa.RemoveAt(oi); } return(ta); } EditorGUILayout.EndHorizontal(); if (!simple) { EditorGUI.indentLevel++; if (bfo) { MakeDefaultEditor(tob); } EditorGUI.indentLevel--; } } EditorGUI.indentLevel--; } return(ob); }
public object Retrieve(int num) { //checking if object is null if (num < 0) { return(null); } //checking if this object was already retrieved if (entities[num].obj != null) { return(entities[num].obj); } SerializedObject entity = entities[num]; System.Type type = System.Type.GetType(entity.typeName); if (type == null) { type = System.Type.GetType(entity.typeName.Substring(0, entity.typeName.IndexOf(","))); //trying to get type using it's short name } if (type == null) { return(null); //in case this type do not exists anymore } //retrieving arrays if (type.IsArray) { Array array = entity.GetValues(type.GetElementType(), this); entity.obj = array; return(array); } //creating instance object obj = System.Activator.CreateInstance(type); entity.obj = obj; //signing record.obj before calling Retrieve to avoid infinite loop //loading values FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance); for (int f = 0; f < fields.Length; f++) { FieldInfo field = fields[f]; if (field.IsLiteral) { continue; //leaving constant fields blank } if (field.FieldType.IsPointer) { continue; //skipping pointers (they make unity crash. Maybe require unsafe) } if (field.IsNotSerialized) { continue; } object val = null; try { val = entity.GetValue(field.FieldType, field.Name, this); } catch (System.Exception e) { Debug.LogError("Serialization error:\n" + e); } field.SetValue(obj, val); } //loading properties PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance); for (int p = 0; p < properties.Length; p++) { PropertyInfo prop = properties[p]; if (!prop.CanWrite) { continue; } if (prop.Name == "Item") { continue; //ignoring this[x] } object val = null; try { val = entity.GetValue(prop.PropertyType, prop.Name, this); } catch (System.Exception e) { Debug.LogError("Serialization error:\n" + e); } if (val != null) { prop.SetValue(obj, val, null); } } return(obj); }
void DrawBaseExcept() { SerializedProperty myProp = serializedObject.GetIterator(); while (myProp.NextVisible(true)) { if (!myProp.isArray && myProp.propertyType != SerializedPropertyType.ArraySize || myProp.isArray && myProp.propertyType == SerializedPropertyType.String) { if (myProp.name != "_parentAsset" && myProp.name != "data") { if (myProp.propertyType == SerializedPropertyType.ObjectReference) { System.Type type = AdvancedScriptableObjectUtility.GetSerializedPropertyType(myProp); if (type != null) { if (type.IsSubclassOf(typeof(AdvancedScriptableObject))) { EditorGUILayout.PropertyField(myProp); //var asoPropEditor = Editor.CreateEditor(myProp.objectReferenceValue); //asoPropEditor.OnInspectorGUI(); //ManualDrawASOProperty(myProp, type); } else { EditorGUILayout.PropertyField(myProp, new GUIContent(myProp.displayName), false); serializedObject.ApplyModifiedProperties(); } } } else { EditorGUILayout.PropertyField(myProp, new GUIContent(myProp.displayName), false); serializedObject.ApplyModifiedProperties(); } } } else if (myProp.isArray) { if (myProp.name != "_protoChildren") { System.Type type = AdvancedScriptableObjectUtility.GetSerializedPropertyType(myProp); if (type != null) { if (type.GetElementType().IsSubclassOf(typeof(AdvancedScriptableObject))) { if (_asoLists.ContainsKey(myProp.name)) { _asoLists[myProp.name].DrawList(); } } else { if (_lists.ContainsKey(myProp.name)) { _lists[myProp.name].DrawList(); } } } } } } }
/// <summary> /// Initializes the <see cref="PropertyBackingFieldDrawer"/> class. /// </summary> static PropertyBackingFieldDrawer() { // add preference menu item string featureGroup = "Property Backing Field"; EditorPreferenceMenu.AddPreferenceMenuItem( featureGroup, () => EditorGUILayout.LabelField("Thanks for your bug reports!") ); EditorPreferenceMenu.AddAssetStoreUrl(featureGroup, 18253); EditorPreferenceMenu.AddSupportForumUrl(featureGroup, "free-and-open-source"); // register callbacks with UnityEditor.Undo Undo.postprocessModifications += OnPerformUndoableAction; Undo.undoRedoPerformed += OnUndoRedo; // get all types incompatible with this feature HashSet <System.Type> typesThatCannotBeBackingFields = new HashSet <System.Type>( ObjectX.AllTypes.Where( t => (t.IsClass || (t.IsValueType && !t.IsEnum && !t.IsPrimitive)) && t.GetCustomAttributes <System.SerializableAttribute>().Count() > 0 && !typeof(IPropertyBackingFieldCompatible).IsAssignableFrom(t) ) ); typesThatCannotBeBackingFields.Remove(typeof(string)); // collect T[] and List<T> for each incompatible type HashSet <System.Type> sequenceTypesThatCannotBeBackingFields = new HashSet <System.Type>(); foreach (System.Type incompatibleType in typesThatCannotBeBackingFields) { sequenceTypesThatCannotBeBackingFields.Add(incompatibleType.MakeArrayType()); sequenceTypesThatCannotBeBackingFields.Add( typeof(List <>).MakeGenericType(new System.Type[] { incompatibleType }) ); } // collect any fields that will cause problems with types that cannot be marked as backing fields Dictionary <System.Type, List <FieldInfo> > problematicFields = new Dictionary <System.Type, List <FieldInfo> >(); // examine all fields on the scripted types to find any problematic usages foreach (System.Type providerType in ObjectX.AllTypes) { foreach (FieldInfo field in providerType.GetFields(ObjectX.instanceBindingFlags)) { System.Type typeToValidate = field.FieldType; // skip the field if it is known to be compatible if ( !typesThatCannotBeBackingFields.Contains(typeToValidate) && !sequenceTypesThatCannotBeBackingFields.Contains(typeToValidate) ) { continue; } // skip the field if it is a built-in Unity type if (ObjectX.UnityRuntimeAssemblies.Contains(typeToValidate.Assembly)) { continue; } // skip the field if it is not serialized if (field.IsPrivate && field.GetCustomAttributes <SerializeField>().Count() == 0) { continue; } // skip the field if it is not designated as a backing field if (field.GetCustomAttributes <PropertyBackingFieldAttribute>().Count() == 0) { continue; } // add the type to the problem table if (typeToValidate.IsArray) { typeToValidate = typeToValidate.GetElementType(); } else if (typeToValidate.IsGenericType) { typeToValidate = typeToValidate.GetGenericArguments()[0]; } if (!problematicFields.ContainsKey(typeToValidate)) { problematicFields.Add(typeToValidate, new List <FieldInfo>()); } // add the field to the type's list of problematic usages problematicFields[typeToValidate].Add(field); } } // display messages for any problems foreach (KeyValuePair <System.Type, List <FieldInfo> > problematicType in problematicFields) { Debug.LogError( string.Format( "<b>{0}</b> must implement <b>{1}<{0}></b>, because it is marked with <b>{2}</b> on the " + "following fields:\n{3}", problematicType.Key, typeof(IPropertyBackingFieldCompatible).FullName, typeof(PropertyBackingFieldAttribute).FullName, string.Join( "\n", ( from field in problematicType.Value select string.Format( " - <i>{0}.{1}</i>", field.DeclaringType, field.Name ) ).ToArray() ) ) ); } }
public static int WriteClass(object obj, List <string> classes, List <UnityEngine.Object> objects, List <float> floats, List <object> references) { //cheking if this object was already saved if (references.Contains(obj)) { return(references.IndexOf(obj)); } //obj type System.Type objType = obj.GetType(); System.Type elementType = objType.IsArray? objType.GetElementType() : null; string objTypeName = objType.ToString(); //reserving a place in array int slotNum = classes.Count; classes.Add(null); //adding to references for (int i = references.Count; i < classes.Count; i++) { references.Add(null); //references count should be equal to classes length } references[slotNum] = obj; //writing StringWriter writer = new StringWriter(); //header writer.Write("<" + objTypeName); if (objType.IsArray) { writer.Write(" length=" + ((Array)obj).Length); } writer.WriteLine(">"); //values foreach (Value val in Values(obj)) { //primitive if (val.type.IsPrimitive) { writer.WriteLine("\t<" + val.name + " type=" + val.type + " value=" + val.obj + "/>"); } //null else if (val.obj == null) { writer.WriteLine("\t<" + val.name + " type=" + val.type + " null/>"); } //string else if (val.type == typeof(string)) { string str = (string)val.obj; str = str.Replace("\n", "\\n"); str = str.Replace(" ", "\\_"); writer.WriteLine("\t<" + val.name + " type=" + val.type + " value=" + str + "/>"); //same as primitive, but after null } //custom struct else if (typeof(IStruct).IsAssignableFrom(val.type)) { writer.WriteLine("\t<" + val.name + " type=" + val.type + " " + ((IStruct)val.obj).Encode() + "/>"); } //custom struct with links else if (typeof(IStructLink).IsAssignableFrom(val.type)) { Func <object, int> getLinkFn = delegate(object linkObj) { return(WriteClass(linkObj, classes, objects, floats, references)); }; writer.WriteLine("\t<" + val.name + " type=" + val.type + " " + ((IStructLink)val.obj).Encode(getLinkFn) + "/>"); } //float array else if (objType == typeof(float[])) //note that obj should be used here, not val.obj { float[] array = (float[])obj; writer.WriteLine("\t<items type=" + val.type + " start=" + floats.Count + " length=" + array.Length + "/>"); floats.AddRange(array); } //other primitive array else if (objType.IsArray && elementType.IsPrimitive) { writer.Write("\t<items type=" + val.type + " values="); Array array = (Array)obj; for (int i = 0; i < array.Length; i++) { writer.Write(array.GetValue(i)); if (i != array.Length - 1) { writer.Write(','); } } writer.WriteLine("/>"); } //class array /*else if (val.classArray) * { * writer.Write( string.Format("\t<items type=" + + " links=", val.type) ); * * Array array = (Array)obj; * for (int i=0; i<array.Length; i++) * { * writer.Write( WriteClass(val.obj, ref classes, ref objects, references) ); * if (i!=array.Length-1) writer.Write(','); * } * * writer.Write("/>\n"); * }*///doesnt deal with null and not tested properly. //unity object else if (val.type.IsSubclassOf(typeof(UnityEngine.Object))) { //not a big deal if the object will be added to array twice writer.WriteLine("\t<" + val.name + " type=" + val.type + " object=" + objects.Count + "/>"); objects.Add((UnityEngine.Object)val.obj); } //null else if (val.obj == null) { writer.WriteLine("\t<" + val.name + " type=" + val.type + " link=-1/>"); } //class else if (val.type.IsClass && !val.type.IsValueType) { writer.WriteLine("\t<" + val.name + " type=" + val.type + " link=" + WriteClass(val.obj, classes, objects, floats, references) + "/>"); } //Vector2 else if (val.type == typeof(Vector2)) { Vector2 v2 = (Vector2)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " x=" + v2.x + " y=" + v2.y + "/>"); //writer.WriteLine("\t<" + val.name + " type=" + val.type + " val=" + floats.Count + "/>"); //floats.Add(v2.x); floats.Add(v2.y); } //Vector3 else if (val.type == typeof(Vector3)) { Vector3 v3 = (Vector3)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " x=" + v3.x + " y=" + v3.y + " z=" + v3.z + "/>"); //writer.WriteLine("\t<" + val.name + " type=" + val.type + " val=" + floats.Count + "/>"); //floats.Add(v3.x); floats.Add(v3.y); floats.Add(v3.z); } //Rect else if (val.type == typeof(Rect)) { Rect rect = (Rect)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " x=" + rect.x + " y=" + rect.y + " width=" + rect.width + " height=" + rect.height + "/>"); //writer.WriteLine("\t<" + val.name + " type=" + val.type + " val=" + floats.Count + "/>"); //floats.Add(rect.x); floats.Add(rect.y); floats.Add(rect.width); floats.Add(rect.height); } //Color else if (val.type == typeof(Color)) { Color c = (Color)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " r=" + c.r + " g=" + c.g + " b=" + c.b + " a=" + c.a + "/>"); } //Vector4 else if (val.type == typeof(Vector4)) { Vector4 v4 = (Vector4)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " x=" + v4.x + " y=" + v4.y + " z=" + v4.z + " w=" + v4.w + "/>"); } //Quaternion else if (val.type == typeof(Quaternion)) { Quaternion q = (Quaternion)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " x=" + q.x + " y=" + q.y + " z=" + q.z + " w=" + q.w + "/>"); } //enum else if (val.type.IsEnum) { writer.WriteLine("\t<" + val.name + " type=" + val.type + " value=" + (int)val.obj + "/>"); } //keyframe else if (val.type == typeof(Keyframe)) { Keyframe k = (Keyframe)val.obj; writer.WriteLine("\t<" + val.name + " type=" + val.type + " time=" + k.time + " value=" + k.value + " in=" + k.inTangent + " out=" + k.outTangent + " mode=" + k.tangentMode + "/>"); } //any other struct (same as class) else { writer.WriteLine("\t<" + val.name + " type=" + val.type + " link=" + WriteClass(val.obj, classes, objects, floats, references) + "/>"); } } //footer writer.WriteLine("</" + objTypeName + ">"); //writing obj writer.Close(); classes[slotNum] = writer.ToString(); return(slotNum); }
private bool ReadComponentValue(StreamReader stream, string fieldEditorType, string fieldObjectType, string fieldValue, ref object parameter) { if (fieldEditorType == "asset") { System.Type type = Assembly.GetAssembly(typeof(UnityEngine.Object)).GetType(fieldObjectType); if (type == null) { //FIXME: Hacky way to get assembly? type = Assembly.GetAssembly(typeof(TextSceneObject)).GetType(fieldObjectType); if (type == null) { Debug.LogError("Failed to get asset type: " + fieldObjectType); return(false); } } if (fieldValue.Length > 0) { string[] assetParts = fieldValue.Split(','); //Expected format: // Asset/Path/Comes/First, AssetName, GUID if (assetParts.Length >= 1) { string assetPath = assetParts[0].Trim(); //We'll use the GUID instead of the filename to get the asset. if (assetParts.Length >= 3) { string guid = assetParts[2].Trim(); assetPath = AssetDatabase.GUIDToAssetPath(guid); } //If there is an assetname defined, we'll search all assets at path instead //of using the root object. if (assetParts.Length >= 2) { Object[] assets = AssetDatabase.LoadAllAssetsAtPath(assetPath); string assetName = assetParts[1].Trim(); foreach (Object asset in assets) { if (asset.GetType() == type && asset.name == assetName) { parameter = asset; break; } } } else { //Just use whatever the assetpath resolves to if no assetname is defined. parameter = AssetDatabase.LoadAssetAtPath(assetPath, type); } } } } else if (fieldEditorType == "scenelink") { System.Type type = Assembly.GetAssembly(typeof(UnityEngine.Object)).GetType(fieldObjectType); if (type == null) { //FIXME: Hacky way to get assembly? type = Assembly.GetAssembly(typeof(TextSceneObject)).GetType(fieldObjectType); if (type == null) { Debug.LogError("Failed to get object type: " + fieldObjectType); return(false); } } if (currentPass == Pass.ValueAssignment && fieldValue.Length > 0) { string prefix = container != null?Helper.GetFullName(container) : ""; string fullName = prefix + fieldValue; GameObject[] matches = Helper.FindGameObjectsFromFullName(fullName); GameObject go = matches.Length > 0 ? matches[0] : null; //FIXME: Why on Earth doesn't this work always? // Try it having a reference to /Geometry/box/box_instance2 and // having a second object in the scene at the path // /Geometry/box/box_instance // Reported unity case #336886 on this. //GameObject go = GameObject.Find(fullName); if (go == null) { EditorUtility.DisplayDialog("Error", "Unable to find object in scene: '" + fullName + "'", "OK"); return(false); } else { if (type.Equals(typeof(GameObject))) { parameter = go; } else { parameter = go.GetComponent(type); } } } } else if (fieldEditorType == "builtinmesh") { if (currentPass == Pass.ValueAssignment) { if (builtinMesh.ContainsKey(fieldValue)) { parameter = builtinMesh[fieldValue]; } else { Debug.LogWarning("Unknown builtin mesh: " + fieldValue); } } } else if (fieldEditorType == "builtinmaterial") { if (currentPass == Pass.ValueAssignment) { parameter = builtinMaterial; } } else if (fieldEditorType == "primitive") { System.Type primitiveType = System.Type.GetType(fieldObjectType); if (primitiveType == null) { primitiveType = Assembly.GetAssembly(typeof(UnityEngine.Object)).GetType(fieldObjectType); } if (primitiveType == null) { primitiveType = Assembly.GetAssembly(typeof(TextSceneObject)).GetType(fieldObjectType); } if (primitiveType == null) { Debug.LogError("No primitive type found for '" + fieldObjectType + "'"); return(false); } //Debug.Log("Handling type: " + fieldObjectType); char [] separators = new char [] { ' ', ',', '(', ')' }; if (typeof(System.Single) == primitiveType) { parameter = ConvertFloat(fieldValue); } else if (typeof(System.Int32) == primitiveType) { parameter = int.Parse(fieldValue, CultureInfo.InvariantCulture); } else if (typeof(System.Boolean) == primitiveType) { parameter = bool.Parse(fieldValue); } else if (typeof(System.String) == primitiveType) { parameter = fieldValue; } else if (typeof(UnityEngine.Vector4) == primitiveType) { string[] v = fieldValue.Split(separators, System.StringSplitOptions.RemoveEmptyEntries); parameter = new Vector4(float.Parse(v[0], CultureInfo.InvariantCulture), float.Parse(v[1], CultureInfo.InvariantCulture), float.Parse(v[2], CultureInfo.InvariantCulture), float.Parse(v[3], CultureInfo.InvariantCulture)); } else if (typeof(UnityEngine.Quaternion) == primitiveType) { string[] v = fieldValue.Split(separators, System.StringSplitOptions.RemoveEmptyEntries); parameter = new Quaternion(float.Parse(v[0], CultureInfo.InvariantCulture), float.Parse(v[1], CultureInfo.InvariantCulture), float.Parse(v[2], CultureInfo.InvariantCulture), float.Parse(v[3], CultureInfo.InvariantCulture)); } else if (typeof(UnityEngine.Vector3) == primitiveType) { string[] v = fieldValue.Split(separators, System.StringSplitOptions.RemoveEmptyEntries); parameter = new Vector3(float.Parse(v[0], CultureInfo.InvariantCulture), float.Parse(v[1], CultureInfo.InvariantCulture), float.Parse(v[2], CultureInfo.InvariantCulture)); } else if (typeof(UnityEngine.Vector2) == primitiveType) { string[] v = fieldValue.Split(separators, System.StringSplitOptions.RemoveEmptyEntries); parameter = new Vector2(float.Parse(v[0], CultureInfo.InvariantCulture), float.Parse(v[1], CultureInfo.InvariantCulture)); } else if (typeof(UnityEngine.Color) == primitiveType) { string[] v = fieldValue.Split(separators, System.StringSplitOptions.RemoveEmptyEntries); parameter = new Color(float.Parse(v[0], CultureInfo.InvariantCulture), float.Parse(v[1], CultureInfo.InvariantCulture), float.Parse(v[2], CultureInfo.InvariantCulture), float.Parse(v[3], CultureInfo.InvariantCulture)); } else if (typeof(UnityEngine.Rect) == primitiveType) { string[] v = fieldValue.Split(separators, System.StringSplitOptions.RemoveEmptyEntries); parameter = new Rect(float.Parse(v[0], CultureInfo.InvariantCulture), float.Parse(v[1], CultureInfo.InvariantCulture), float.Parse(v[2], CultureInfo.InvariantCulture), float.Parse(v[3], CultureInfo.InvariantCulture)); } else if (primitiveType.IsEnum) { string[] names = System.Enum.GetNames(primitiveType); System.Array values = System.Enum.GetValues(primitiveType); for (int ei = 0; ei < names.Length; ei++) { if (names[ei] == fieldValue) { //Debug.Log(primitiveType.ToString() + ": '" + names[ei] + "' set value: '" + fieldValue + "'"); parameter = values.GetValue(ei); break; } } } else { Debug.LogWarning("Unhandled field type: " + fieldObjectType); } } else if (fieldEditorType == "array") { System.Type arrayType = System.Type.GetType(fieldObjectType); if (arrayType == null) { arrayType = Assembly.GetAssembly(typeof(UnityEngine.Object)).GetType(fieldObjectType); } //FIXME: Hacky way to get assembly? if (arrayType == null) { arrayType = Assembly.GetAssembly(typeof(TextSceneObject)).GetType(fieldObjectType); } if (arrayType == null) { Debug.LogWarning("Found array of unresolvable type: " + fieldObjectType); return(false); } System.Type arrayElementType = arrayType.GetElementType(); parameter = System.Array.CreateInstance(arrayElementType, int.Parse(fieldValue, CultureInfo.InvariantCulture)); System.Array arrayEntries = parameter as System.Array; //Debug.Log("Found array: " + arrayElementType.ToString() + " length: " + arrayEntries.Length); for (int e = 0; e < arrayEntries.Length; e++) { string arrayEntryLine = stream.ReadLine().Trim(); //Debug.Log("Reading array entry: " + arrayEntryLine); string[] elements = arrayEntryLine.Split(); string editorType = elements[0]; string objectType = elements[1]; string val = arrayEntryLine.Substring(arrayEntryLine.LastIndexOf('=') + 1).Trim(); //Debug.Log("Array entry: " + editorType + " " + objectType + " = " + val); object arrayEntry = null; ReadComponentValue(stream, editorType, objectType, val, ref arrayEntry); arrayEntries.SetValue(arrayEntry, e); } } else if (fieldEditorType == "complex") { System.Type complexType = System.Type.GetType(fieldObjectType); if (complexType == null) { complexType = Assembly.GetAssembly(typeof(UnityEngine.Object)).GetType(fieldObjectType); } //FIXME: Hacky way to get assembly? if (complexType == null) { complexType = Assembly.GetAssembly(typeof(TextSceneObject)).GetType(fieldObjectType); } if (complexType == null) { Debug.LogWarning("Failed to find type: " + fieldObjectType); return(false); } parameter = System.Activator.CreateInstance(complexType); int members = int.Parse(fieldValue, CultureInfo.InvariantCulture); //Debug.Log("Reading complex type: " + complexType.ToString() + " members: " + members); for (int i = 0; i < members; i++) { ProcessValueLine(stream, fieldObjectType, parameter); } return(true); } else { return(false); } return(true); }
static public void DoUpdateGetComponentAttribute(MonoBehaviour pTargetMono, object pMemberOwner, MemberInfo pMemberInfo) { object[] arrCustomAttributes = pMemberInfo.GetCustomAttributes(true); for (int i = 0; i < arrCustomAttributes.Length; i++) { IGetComponentAttribute pGetcomponentAttribute = arrCustomAttributes[i] as IGetComponentAttribute; if (pGetcomponentAttribute == null) { continue; } System.Type pTypeMember = pMemberInfo.MemberType(); object pComponent = null; if (pTypeMember.IsGenericType) { pComponent = SetMember_OnGeneric(pGetcomponentAttribute, pTargetMono, pMemberOwner, pMemberInfo, pTypeMember); } else if (pTypeMember.HasElementType) { pComponent = pGetcomponentAttribute.GetComponent(pTargetMono, pTypeMember.GetElementType()); } else { pComponent = pGetcomponentAttribute.GetComponent(pTargetMono, pTypeMember); } if (pComponent == null) { if (pGetcomponentAttribute.bIsPrint_OnNotFound_GetComponent) { GetComponentInChildrenAttribute pAttribute = pGetcomponentAttribute as GetComponentInChildrenAttribute; if (pAttribute != null && pAttribute.bSearch_By_ComponentName) { Debug.LogError(pTargetMono.name + string.Format(".{0}<{1}>({2}) Result == null", pGetcomponentAttribute.GetType().Name, pTypeMember, pAttribute.strComponentName), pTargetMono); } else { Debug.LogError(pTargetMono.name + string.Format(".{0}<{1}> Result == null", pGetcomponentAttribute.GetType().Name, pTypeMember), pTargetMono); } } continue; } if (pTypeMember.IsGenericType == false) { if (pTypeMember.HasElementType == false) { Array arrComponent = pComponent as Array; if (arrComponent != null && arrComponent.Length != 0) { pMemberInfo.SetValue_Extension(pMemberOwner, arrComponent.GetValue(0)); } } else { if (pTypeMember == typeof(GameObject)) { pMemberInfo.SetValue_Extension(pMemberOwner, ((Component)pComponent).gameObject); } else { pMemberInfo.SetValue_Extension(pMemberOwner, pComponent); } } } } }