GetElementType() публичный метод

public GetElementType ( ) : Type
Результат Type
Пример #1
1
		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());
		}
Пример #2
0
		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;
		}
Пример #3
0
        /// <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;
        }
Пример #4
0
        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;
        }
Пример #6
0
        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;
        }
Пример #7
0
 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";
        }
Пример #9
0
        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();
        }
Пример #10
0
    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);
    }
Пример #11
0
        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);
        }
Пример #12
0
        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;
        }
Пример #13
0
        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;
        }
Пример #14
0
 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;
 }
Пример #15
0
 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);
			}
		}
Пример #18
0
 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();
        }
Пример #20
0
        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;
 }
Пример #22
0
        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()");
            }
        }
Пример #23
0
        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;
        }
Пример #24
0
		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();
 }
Пример #26
0
        public GetTypeForm(Type currType, object data)
        {
            if (currType.GetElementType() != null)
            {
                m_currType = currType.GetElementType();
            }
            else
            {
                m_currType = currType;
            }

            m_data = data;

            InitializeComponent();
        }
Пример #27
0
    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();
 }
Пример #29
0
    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);
        }
    }
Пример #30
0
 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;
 }
Пример #31
0
    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));
        }
    }
Пример #32
0
        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 });
        }
Пример #33
0
        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;
        }
Пример #35
0
    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);
    }
Пример #36
0
 private static bool IsEnumType(System.Type t)
 {
     if (t.IsByRef)
     {
         t = t.GetElementType();
     }
     return(t.IsEnum);
 }
Пример #37
0
 private static bool IsPrimitiveType(System.Type t)
 {
     if (t.IsByRef)
     {
         t = t.GetElementType();
     }
     return(t.IsPrimitive);
 }
Пример #38
0
    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);
    }
Пример #39
0
 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);
 }
Пример #40
0
    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));
    }
Пример #41
0
    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);
    }
Пример #42
0
    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);
     }
 }
Пример #44
0
    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());
    }
Пример #45
0
        /// <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);
        }
Пример #46
0
        /// <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);
            }
        }
Пример #47
0
        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));
        }
Пример #48
0
        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);
        }
Пример #49
0
        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);
        }
Пример #50
0
        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}");
        }
Пример #51
0
 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));
     }
 }
Пример #52
0
 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)));
     }
 }
Пример #53
0
        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;
                }
            }
        }
Пример #54
0
    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);
    }
Пример #55
0
        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);
        }
Пример #56
0
    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();
                            }
                        }
                    }
                }
            }
        }
    }
Пример #57
0
    /// <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()
                        )
                    )
                );
        }
    }
Пример #58
0
        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);
        }
Пример #59
0
    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);
                    }
                }
            }
        }
    }