///---------------------------------------------------------------------------------------------- //Find nodes of type (T) having the [DropReferenceType] attribute pointing to target unity object type public static IEnumerable <System.Type> GetDropedReferenceNodeTypes <T>(UnityEngine.Object obj) where T : IGraphElement { var targetType = obj.GetType(); foreach (var type in ReflectionTools.GetImplementationsOf(typeof(T))) { var att = type.RTGetAttribute <DropReferenceType>(true); if (att != null && att.type == targetType) { yield return(type); } } }
///Returns whether there is a CustomObjectWrapper implemented for target type public static System.Type[] FindCustomObjectWrappersForType(System.Type targetType) { var results = new List <System.Type>(); foreach (var type in ReflectionTools.GetImplementationsOf(typeof(CustomObjectWrapper))) { var args = type.BaseType.GetGenericArguments(); if (args.Length == 1 && args[0] == targetType) { results.Add(type); } } return(results.ToArray()); }
///Return an object drawer instance of target inspected type public static IObjectDrawer GetObjectDrawer(Type objectType) { IObjectDrawer result = null; if (objectDrawers.TryGetValue(objectType, out result)) { return(result); } // look for specific drawer first Type fallbackDrawerType = null; foreach (var drawerType in ReflectionTools.GetImplementationsOf(typeof(IObjectDrawer))) { if (drawerType != typeof(DefaultObjectDrawer)) { var args = drawerType.BaseType.RTGetGenericArguments(); if (args.Length == 1) { if (args[0].IsEquivalentTo(objectType)) { return(objectDrawers[objectType] = Activator.CreateInstance(drawerType) as IObjectDrawer); } if (args[0].IsAssignableFrom(objectType)) { fallbackDrawerType = drawerType; } } } } if (fallbackDrawerType != null) { return(objectDrawers[objectType] = Activator.CreateInstance(fallbackDrawerType) as IObjectDrawer); } // foreach ( var drawerType in ReflectionTools.GetImplementationsOf(typeof(IObjectDrawer)) ) { // if ( drawerType != typeof(DefaultObjectDrawer) ) { // var args = drawerType.BaseType.RTGetGenericArguments(); // if ( args.Length == 1 && args[0].IsAssignableFrom(objectType) ) { // return objectDrawers[objectType] = Activator.CreateInstance(drawerType) as IObjectDrawer; // } // } // } return(objectDrawers[objectType] = new DefaultObjectDrawer(objectType)); }
public static Type GetExtractorType(Type type) { if (_extractors == null) { _extractors = new Dictionary <Type, Type>(); var extractorTypes = ReflectionTools.GetImplementationsOf(typeof(ExtractorNode)).Where(t => !t.IsGenericTypeDefinition); foreach (var extractorType in extractorTypes) { var invokeMethod = extractorType.RTGetMethod("Invoke"); var targetType = invokeMethod.GetParameters()[0].ParameterType; _extractors[targetType] = extractorType; } } Type result = null; _extractors.TryGetValue(type, out result); return(result); }
///Return an attribute drawer instance of target attribute type public static IAttributeDrawer GetAttributeDrawer(Type attributeType) { IAttributeDrawer result = null; if (attributeDrawers.TryGetValue(attributeType, out result)) { return(result); } foreach (var drawerType in ReflectionTools.GetImplementationsOf(typeof(IAttributeDrawer))) { if (drawerType != typeof(DefaultAttributeDrawer)) { var args = drawerType.BaseType.GetGenericArguments(); if (args.Length == 1 && args[0].IsAssignableFrom(attributeType)) { return(attributeDrawers[attributeType] = Activator.CreateInstance(drawerType) as IAttributeDrawer); } } } return(attributeDrawers[attributeType] = new DefaultAttributeDrawer(attributeType)); }
public static List <ScriptInfo> GetScriptInfosOfType(Type baseType) { if (cachedInfos == null) { cachedInfos = new Dictionary <Type, List <ScriptInfo> >(); } List <ScriptInfo> infosResult; if (cachedInfos.TryGetValue(baseType, out infosResult)) { return(infosResult.ToList()); } infosResult = new List <ScriptInfo>(); var subTypes = ReflectionTools.GetImplementationsOf(baseType); if (baseType.IsGenericTypeDefinition) { subTypes = new Type[] { baseType }; } foreach (var subType in subTypes) { if (subType.IsAbstract || subType.IsDefined(typeof(DoNotListAttribute), true) || subType.IsDefined(typeof(ObsoleteAttribute), true)) { continue; } var isGeneric = subType.IsGenericTypeDefinition && subType.GetGenericArguments().Length == 1; var scriptName = subType.FriendlyName().SplitCamelCase(); var scriptCategory = string.Empty; var scriptPriority = 0; var nameAttribute = subType.RTGetAttribute <NameAttribute>(true); if (nameAttribute != null) { scriptPriority = nameAttribute.priority; scriptName = nameAttribute.name; if (isGeneric && !scriptName.EndsWith("<T>")) { scriptName += " (T)"; } } var categoryAttribute = subType.RTGetAttribute <CategoryAttribute>(true); if (categoryAttribute != null) { scriptCategory = categoryAttribute.category; } var info = new ScriptInfo(subType, scriptName, scriptCategory, scriptPriority); info.originalType = subType; info.originalName = scriptName; info.originalCategory = scriptCategory; //add the generic types based on constrains and prefered types list if (isGeneric) { var exposeAsBaseDefinition = subType.RTIsDefined <ExposeAsDefinitionAttribute>(true); if (!exposeAsBaseDefinition) { var typesToWrap = TypePrefs.GetPreferedTypesList(true); foreach (var t in typesToWrap) { infosResult.Add(info.MakeGenericInfo(t, string.Format("/{0}/{1}", info.name, t.NamespaceToPath()))); infosResult.Add(info.MakeGenericInfo(typeof(List <>).MakeGenericType(t), string.Format("/{0}/{1}{2}", info.name, TypePrefs.LIST_MENU_STRING, t.NamespaceToPath()), -1)); infosResult.Add(info.MakeGenericInfo(typeof(Dictionary <,>).MakeGenericType(typeof(string), t), string.Format("/{0}/{1}{2}", info.name, TypePrefs.DICT_MENU_STRING, t.NamespaceToPath()), -2)); } continue; } } infosResult.Add(info); } infosResult = infosResult .Where(s => s != null) .OrderBy(s => s.GetBaseInfo().name) .OrderBy(s => s.GetBaseInfo().priority * -1) .OrderBy(s => s.GetBaseInfo().category) .ToList(); cachedInfos[baseType] = infosResult; return(infosResult); }
static fsSerializer() { _directConverterTypes = ReflectionTools.GetImplementationsOf(typeof(fsDirectConverter)); }