private static void PopulateKnownSerializers()
{
object obj;
Type[] typeArray;
int i;
foreach (Type type in ApexReflection.GetRelevantTypes().Where <Type>((Type t) => {
if (!typeof(IValueConverter).IsAssignableFrom(t) && !typeof(IStager).IsAssignableFrom(t) && !typeof(ISerializer).IsAssignableFrom(t) || t.IsAbstract)
{
return(false);
}
return(t.GetConstructor(Type.EmptyTypes) != null);
}))
{
FieldInfo field = type.GetField("instance", BindingFlags.Static | BindingFlags.Public);
obj = (field == null ? Activator.CreateInstance(type) : field.GetValue(null));
IValueConverter valueConverter = obj as IValueConverter;
if (valueConverter != null)
{
if (valueConverter.handledTypes == null)
{
continue;
}
typeArray = valueConverter.handledTypes;
for (i = 0; i < (int)typeArray.Length; i++)
{
Type type1 = typeArray[i];
if (!SerializationMaster._typeConverters.ContainsKey(type1) || type.IsDefined <SerializationOverrideAttribute>(false))
{
SerializationMaster._typeConverters[type1] = valueConverter;
}
}
}
else if (!(obj is ISerializer) || SerializationMaster._serializer != null && !type.IsDefined <SerializationOverrideAttribute>(false))
{
IStager stager = obj as IStager;
if (stager.handledTypes == null)
{
continue;
}
typeArray = stager.handledTypes;
for (i = 0; i < (int)typeArray.Length; i++)
{
Type type2 = typeArray[i];
if (!SerializationMaster._typeStagers.ContainsKey(type2) || type.IsDefined <SerializationOverrideAttribute>(false))
{
SerializationMaster._typeStagers[type2] = stager;
}
}
}
else
{
SerializationMaster._serializer = (ISerializer)obj;
}
}
}
private static IEnumerable <Type> GetDerived(Type forType)
{
return(ApexReflection.GetRelevantTypes().Where <Type>((Type t) => {
if (!t.IsClass || t.IsAbstract)
{
return false;
}
return forType.IsAssignableFrom(t);
}));
}
private void ShowContextSelector()
{
object cp = _target.As <IContextProvider>();
if (cp == null)
{
if (_contextProviderList == null)
{
_contextProviderList = new List <KeyValuePair <string, Type> >();
_contextProviderList = (from t in ApexReflection.GetRelevantTypes()
where typeof(IContextProvider).IsAssignableFrom(t) && !t.IsAbstract
orderby t.Name
select new KeyValuePair <string, Type>(t.Name, t)).ToList();
_contextProviderNames = _contextProviderList.Select(p => p.Key).ToArray();
}
EditorGUILayout.Separator();
var style = new GUIStyle(GUI.skin.label);
style.normal.textColor = Color.yellow;
if (_contextProviderList.Count == 0)
{
EditorGUILayout.LabelField("A Context Provider is required!", style);
EditorGUILayout.BeginHorizontal();
_nameSpace = EditorGUILayout.TextField("Namespace", _nameSpace);
if (GUILayout.Button("Create a Context Provider"))
{
ContextGenerator.WriteContextFiles(_nameSpace);
EditorUtility.DisplayDialog("Context Created", "A basic Context and Context provider has been created in the root of the Assets folder.\n\nPlease review the documentation for additional details on Contexts.", "Ok");
}
EditorGUILayout.EndHorizontal();
}
else if (_contextProviderList.Count == 1)
{
_target.gameObject.AddComponent(_contextProviderList[0].Value);
}
else
{
EditorGUILayout.LabelField("Select a Context Provider", style);
var selectedIdx = EditorGUILayout.Popup(-1, _contextProviderNames);
if (selectedIdx >= 0)
{
_target.gameObject.AddComponent(_contextProviderList[selectedIdx].Value);
}
}
}
}
private void Investigate(AIStorage[] ais)
{
var availableTypes = from t in ApexReflection.GetRelevantTypes()
where !t.IsAbstract && (!_excludeApexTypes || t.Namespace == null || !t.Namespace.StartsWith("Apex.AI")) && (t.IsDefined <ApexSerializedTypeAttribute>(true) || SerializationMaster.GetSerializedProperties(t).Any() || SerializationMaster.GetSerializedFields(t).Any())
orderby t.FullName
select new TypeNameTokens(t.AssemblyQualifiedName);
var aiLookup = new Dictionary <string, ReferencingAI>(StringComparer.Ordinal);
foreach (var ai in ais)
{
aiLookup.Add(ai.aiId, new ReferencingAI(ai.name));
}
_referencedTypes.Clear();
_unreferencedTypes.Clear();
foreach (var t in availableTypes)
{
var refType = new ReferencedType(t.fullTypeName);
foreach (var ai in ais)
{
if (ai.configuration.Contains(t.completeTypeName))
{
var refAI = aiLookup[ai.aiId];
refAI.referencedTypes.Add(refType);
refType.referencingAIs.Add(refAI);
}
}
if (refType.referencingAIs.Count > 0)
{
_referencedTypes.Add(refType);
}
else
{
_unreferencedTypes.Add(t);
}
}
_referencingAIs = (from ai in aiLookup.Values
where ai.referencedTypes.Count > 0
orderby ai.name
select ai).ToArray();
_step = Step.Result;
_owner.Repaint();
}
private static void PopulateKnownEditorFields()
{
var relevantTypes = ApexReflection.GetRelevantTypes();
var editorFields = from t in relevantTypes
let tha = t.GetAttribute <TypesHandledAttribute>(true)
where tha != null && typeof(IEditorField).IsAssignableFrom(t) && !t.IsAbstract && t.GetConstructor(new Type[] { typeof(MemberData), typeof(object) }) != null
select new
{
fieldType = t,
typesHandled = tha.typesHandled
};
foreach (var field in editorFields)
{
foreach (var t in field.typesHandled)
{
_typedEditorFields[t] = field.fieldType;
}
}
}
internal void Begin(AIStorage[] ais)
{
_ais = ais;
_repairedAIIds = null;
_identifiedTypes = new Dictionary <string, Type>();
_stagedAis = new StageElement[ais.Length];
for (int i = 0; i < ais.Length; i++)
{
_stagedAis[i] = SerializationMaster.Deserialize(ais[i].configuration);
}
if (_customTasks == null)
{
_customTasks = (from t in ApexReflection.GetRelevantTypes()
where !t.IsAbstract && typeof(IRepairTask).IsAssignableFrom(t) && t.GetConstructor(Type.EmptyTypes) != null
select Activator.CreateInstance(t) as IRepairTask).OrderByDescending(t => t.versionThreshold).ToArray();
}
if (_customTasks.Length > 0)
{
for (int i = 0; i < ais.Length; i++)
{
var aiVersion = new AIVersion(ais[i].version).ToVersion();
for (int j = 0; j < _customTasks.Length; j++)
{
var task = _customTasks[j];
if (task.versionThreshold >= aiVersion)
{
var editorCfg = task.repairsEditorConfiguration ? GetEditorDoc(i) : null;
if (task.Repair(_stagedAis[i], editorCfg))
{
this.customRepairsMade = true;
}
}
}
}
}
}
private static void PopulateKnownSerializers()
{
var relevantTypes = ApexReflection.GetRelevantTypes();
var serializerTypes = from t in relevantTypes
where (typeof(IValueConverter).IsAssignableFrom(t) || typeof(IStager).IsAssignableFrom(t) || typeof(ISerializer).IsAssignableFrom(t)) &&
!t.IsAbstract && t.GetConstructor(Type.EmptyTypes) != null
select t;
foreach (var st in serializerTypes)
{
object instance;
var singletonField = st.GetField("instance", BindingFlags.Public | BindingFlags.Static);
if (singletonField != null)
{
instance = singletonField.GetValue(null);
}
else
{
instance = Activator.CreateInstance(st);
}
var vc = instance as IValueConverter;
if (vc != null)
{
if (vc.handledTypes == null)
{
continue;
}
foreach (var t in vc.handledTypes)
{
if (!_typeConverters.ContainsKey(t) || st.IsDefined <SerializationOverrideAttribute>(false))
{
_typeConverters[t] = vc;
}
}
}
else if (instance is ISerializer && (_serializer == null || st.IsDefined <SerializationOverrideAttribute>(false)))
{
_serializer = (ISerializer)instance;
}
else
{
var s = instance as IStager;
if (s.handledTypes == null)
{
continue;
}
foreach (var t in s.handledTypes)
{
if (!_typeStagers.ContainsKey(t) || st.IsDefined <SerializationOverrideAttribute>(false))
{
_typeStagers[t] = s;
}
}
}
}
}
private static IEnumerable <Type> GetDerived(Type forType)
{
return(from t in ApexReflection.GetRelevantTypes()
where t.IsClass && !t.IsAbstract && forType.IsAssignableFrom(t)
select t);
}
private static IEnumerable <Type> GetConstructableTypes()
{
return(from t in ApexReflection.GetRelevantTypes()
where !t.IsAbstract && !t.IsDefined <HiddenAttribute>(false) && t.GetConstructor(Type.EmptyTypes) != null
select t);
}
