private static bool PostProcess(DataRoute route, IPostProcessAssets processor)
{
var declarationType = processor.GetDeclarationType();
switch (declarationType)
{
case DeclarationType.Single:
{
return(PostProcessUtility.InvokeSingle(route.StoredValue, processor, route.RootType));;
}
case DeclarationType.List:
{
return(PostProcessUtility.InvokeList(route.StoredValue, processor, route.RootType));
}
case DeclarationType.Dictionary:
var keyType = route.DictionaryKeyType;
var valueType = route.RootType;
{
return(PostProcessUtility.InvokeDictionary(route.StoredValue, processor, keyType, valueType));
}
}
return(false);
}
public static bool InvokeList(object storedValue, IPostProcessAssets postProcessor, Type elementType)
{
return(Invoke(PostProcessListMethodInfo,
storedValue,
postProcessor,
elementType));
}
public static bool InvokeSingle(object storedValue, IPostProcessAssets postProcessor, Type singleType)
{
return(Invoke(PostProcessSingleMethodInfo,
storedValue,
postProcessor,
singleType));
}
public static DeclarationType GetDeclarationType(this IPostProcessAssets postprocessor)
{
var interfaces = postprocessor.GetType().GetInterfaces();
Func <Type, bool> check = b =>
b.IsInstanceOfType(postprocessor) ||
interfaces.Any(i => b == i ||
b.IsAssignableFrom(i) ||
(i.IsGenericType && i.GetGenericTypeDefinition() == b));
if (check(PostProcessSingleType))
{
return(DeclarationType.Single);
}
if (check(PostProcessListType))
{
return(DeclarationType.List);
}
if (check(PostProcessDictionaryType))
{
return(DeclarationType.Dictionary);
}
throw new NotImplementedException(postprocessor.GetType().FullName);
}
private static void PostProcessList <T>(object storedValueObject, IPostProcessAssets postProcessAssets)
{
var pp = (IPostProcessAssetList <T>)postProcessAssets;
var v = (List <T>)storedValueObject;
pp.OnPostProcess(v);
}
public static bool InvokeDictionary(object storedValue, IPostProcessAssets postProcessor, Type keyType, Type valueType)
{
return(Invoke(PostProcessDictionaryMethodInfo,
storedValue,
postProcessor,
keyType,
valueType));
}
private static bool Invoke(MethodInfo genericMethodInfo,
object storedValue,
IPostProcessAssets postProcessor,
params Type[] typeArguments)
{
try
{
Get(genericMethodInfo, typeArguments)(storedValue, postProcessor);
return(true);
}
catch (Exception e)
{
LogUtils.Verbose(e);
}
return(false);
}
public static void Init()
{
if (_init)
{
return;
}
LogUtils.Verbose("Context.Init");
_init = true;
foreach (var source in Sources)
{
_assets[source.GetAssetPath()] = source;
}
foreach (var storage in Storages)
{
_assets[storage.GetAssetPath()] = storage;
}
var assemblies = Assemblies;
if (assemblies.ProxyAssembly == null)
{
return;
}
try
{
var roots = Roots;
var wellLocatedRoots = new List <RootDefinition>();
foreach (var r in roots.All)
{
if (!assemblies.IsAssemblyValidForRoot(r.Assembly))
{
LogUtils.Warning($"Config root {r.Root.FullName} is defined in assembly {r.Assembly.FullName}. This is not supported - please put it into separate assembly with AssemblyDefinition or manually.");
continue;
}
wellLocatedRoots.Add(r);
}
var validGroups = new List <string>();
var validAttributes = new List <AssetDeclarationAttributeBase>();
var attributes = wellLocatedRoots.SelectMany(r => r.Attributes)
.ToList();
var groups = attributes.Select(a => a.Group)
.ToList();
foreach (var attribute in attributes)
{
if (groups.Count(g => g == attribute.Group) > 1)
{
var duplicateRoots = wellLocatedRoots.Where(r => r.Contains(attribute.Group));
var log = new StringBuilder();
log.AppendFormat("Group name \"{0}\" is declared multiple times. This is not supported.",
attribute.Group)
.AppendLine();
log.AppendLine("Declarations found in these types:");
foreach (var root in duplicateRoots)
{
log.AppendFormat("{0} ({1})", root.Root.Name, root.Root.AssemblyQualifiedName)
.AppendLine();
}
log.AppendLine("These group will be ignored until duplication is fixed.");
LogUtils.Error(log);
continue;
}
if (!CodeGenerationUtility.IsValidGroupName(attribute.Group))
{
LogUtils.Error($"Group {attribute.Group} name is not valid! Group will be ignored.");
continue;
}
validAttributes.Add(attribute);
validGroups.Add(attribute.Group);
}
_groups = validGroups;
Attributes = validAttributes;
}
catch (Exception e)
{
LogUtils.Verbose(e);
}
try
{
var postprocessorType = typeof(IPostProcessAssets);
var postprocessorTypes = assemblies.All
.SelectMany(a => a.GetTypes())
.Where(t => !t.IsAbstract && !t.IsInterface)
.Where(t => postprocessorType.IsAssignableFrom(t))
.ToList();
PostProcessors = new List <IPostProcessAssets>();
var ordered = new Dictionary <int, List <IPostProcessAssets> >();
var orders = new Dictionary <IPostProcessAssets, PostProcessOrderAttribute>();
var defaultOrder = new PostProcessOrderAttribute();
Func <int, List <IPostProcessAssets> > getGroup = i =>
{
List <IPostProcessAssets> g;
if (ordered.TryGetValue(i, out g))
{
return(g);
}
g = new List <IPostProcessAssets>();
ordered[i] = g;
return(g);
};
Func <IPostProcessAssets, PostProcessOrderAttribute> getOrder = a =>
{
PostProcessOrderAttribute o;
if (!orders.TryGetValue(a, out o) ||
o == null)
{
o = defaultOrder;
}
return(o);
};
foreach (var type in postprocessorTypes)
{
try
{
var instance = Activator.CreateInstance(type, type.IsNotPublic) as IPostProcessAssets;
PostProcessors.Add(instance);
var order = type.GetSingle <PostProcessOrderAttribute>()
?? defaultOrder;
orders[instance] = order;
getGroup(order.Group).Add(instance);
}
catch (Exception e)
{
LogUtils.Verbose(e);
}
}
foreach (var p in ordered)
{
p.Value.Sort((a1, a2) => getOrder(a1).Order.CompareTo(getOrder(a1).Order));
}
OrderedPostProcessors = new IPostProcessAssets[ordered.Count][];
var index = 0;
foreach (var groupIndex in ordered.Keys.OrderBy(k => k))
{
var g = ordered[groupIndex];
if (g == null || g.Count == 0)
{
continue;
}
OrderedPostProcessors[index] = g.ToArray();
index++;
}
}
catch (Exception e)
{
LogUtils.Verbose(e);
}
}
private static void PostProcessDictionary <TKey, TValue>(object storedValueObject, IPostProcessAssets postProcessAssets)
{
var pp = (IPostProcessAssetDictionary <TKey, TValue>)postProcessAssets;
var v = (Dictionary <TKey, TValue>)storedValueObject;
pp.OnPostProcess(v);
}