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);
}
internal static void Rebuild(DataRoute route, YamlyProjectContext ctx)
{
var groupName = route.Group;
if (route.Sources.Count == 0)
{
Debug.LogWarning($"Group {groupName} have no sources.");
return;
}
if (route.Storages.Count == 0)
{
Debug.LogWarning($"Group {groupName} have no storages.");
return;
}
if (Settings.VerboseLogs)
{
Debug.Log($"Rebuild group {groupName} from {route.Sources.Count} sources to {route.Storages.Count} storages.");
}
var result = ctx.AssetProcessor.Rebuild(route);
foreach (var e in result.Errors)
{
Debug.LogError(e.Error, e.TextAsset);
}
}
internal static void Rebuild(DataRoute route)
{
Context.Init();
var groupName = route.Group;
if (route.Sources.Count == 0)
{
LogUtils.Warning($"[{groupName}]: Group have no sources.");
return;
}
if (route.Storages.Count == 0)
{
LogUtils.Warning($"[{groupName}]: Group have no storages.");
return;
}
LogUtils.Verbose($"[{groupName}] Rebuild from {route.Sources.Count} sources to {route.Storages.Count} storages.");
var result = Context.AssetProcessor.Rebuild(route);
foreach (var e in result.Errors)
{
LogUtils.Error(e.Error, e.TextAsset);
}
}
private static DataRoute CreateRoute(RootDefinition d,
AssetDeclarationAttributeBase a,
List <SourceBase> sources,
List <Storage> storages)
{
var route = new DataRoute
{
Root = d,
Attribute = a,
Sources = sources.FindAll(s => s.Contains(a.Group)),
Storages = storages.FindAll(s => s.Includes(a.Group)),
};
if (route.Attribute.IsSingle())
{
var storage = route.Sources.Where(s1 => s1.IsSingle)
.Cast <SingleSource>()
.FirstOrDefault(s => s != null && s.GetAsset(route.Group) != null);
var asset = storage != null?storage.GetAsset(route.Group) : null;
if (asset != null)
{
route.FileAssetPaths.Add(asset.GetAssetPath());
}
}
else
{
foreach (var source in route.Sources)
{
if (source.IsSingle)
{
var asset = source.GetSingleAsset(route.Group);
if (asset != null)
{
route.FileAssetPaths.Add(asset.GetAssetPath());
}
}
else
{
var isRecursive = (source as FolderSource)?.IsRecursive ?? false;
var paths = isRecursive ? route.RootAssetPaths : route.FolderAssetPaths;
paths.Add(source.GetAssetPathFolder());
}
}
route.FileAssetPaths.AddRange(route.Sources.SelectMany(s => s.GetAssets(route.Attribute)).Select(textAsset => textAsset.GetAssetPath()));
}
foreach (var storage in route.Storages)
{
route.FileAssetPaths.Add(storage.GetAssetPath());
}
foreach (var source in route.Sources)
{
route.FileAssetPaths.Add(source.GetAssetPath());
}
return(route);
}
public AssetsValidationResult Rebuild(DataRoute route)
{
var result = Validate(route);
if (route.Storages.Any() &&
GetStorageType(route) != null)
{
SetStoredValue(route, result.StoredValue);
}
return(result);
}
private static Func <MethodInfo, object, TextAsset, object> GetGetKeyFunc(DataRoute route,
MethodInfo methodInfo)
{
if (methodInfo == null)
{
return(null);
}
var parameters = methodInfo.GetParameters();
Func <MethodInfo, object, TextAsset, object> getKeyFunc = null;
if (parameters.Length == 0 &&
!methodInfo.IsStatic)
{
getKeyFunc = (m, v, a) => m.Invoke(v, null);
}
if (!methodInfo.IsStatic)
{
return(getKeyFunc);
}
if (parameters.Length == 1)
{
getKeyFunc = (m, v, a) => m.Invoke(null, new[] { v });
}
else if (parameters.Length == 2)
{
if (parameters[0].ParameterType == typeof(TextAsset))
{
getKeyFunc = (m, v, a) => m.Invoke(null, new[] { a, v });
}
if (parameters[0].ParameterType == route.RootType)
{
getKeyFunc = (m, v, a) => m.Invoke(null, new[] { v, a });
}
}
return(getKeyFunc);
}
internal static void PostProcess(DataRoute route)
{
Context.Init();
var groupName = route.Group;
if (route.Sources.Count == 0)
{
LogUtils.Warning($"[{groupName}]: Group have no sources.");
return;
}
if (route.Storages.Count == 0)
{
LogUtils.Warning($"[{groupName}]: Group have no storages.");
return;
}
LogUtils.Verbose($"[{groupName}] PostProcess from {route.Sources.Count} sources to {route.Storages.Count} storages.");
Context.AssetProcessor.PostProcess(route);
}
public bool PostProcess(DataRoute route)
{
var anySuccess = false;
foreach (var postProcessGroup in Context.OrderedPostProcessors)
{
foreach (var postProcessor in postProcessGroup.Where(p => p.Group == route.Group))
{
if (PostProcess(route, postProcessor))
{
anySuccess = true;
}
}
}
if (anySuccess)
{
SetStoredValue(route, route.StoredValue);
}
return(anySuccess);
}
public void SetStoredValue(DataRoute route, object storedValue)
{
var storageType = GetStorageType(route);
foreach (var storageDefinition in route.Storages)
{
var getStorage = Create <Func <StorageBase> >(_getStorageMethodInfo.MakeGenericMethod(storageType), storageDefinition);
var storage = getStorage?.Invoke();
if (storage == null)
{
storage = CreateStorage(storageType);
storage.name = storage.Group;
AssetDatabase.AddObjectToAsset(storage, storageDefinition);
storageDefinition.SetStorage(route.Group, storage);
}
SetValue(storedValue, storage);
EditorUtility.SetDirty(storageDefinition);
}
}
private Type GetStorageType(DataRoute dataRoute)
{
return(GetStorageType(dataRoute.RootType, dataRoute.Group));
}
public AssetsValidationResult Validate(DataRoute route)
{
var result = new AssetsValidationResult();
var errors = result.Errors;
var values = new Dictionary <TextAsset, object>();
var type = route.GetValueType();
foreach (var assetPath in route.GetAssetPaths().Distinct())
{
var textAsset = Context.GetAsset <TextAsset>(assetPath);
if (textAsset != null)
{
var namingConvention = route.Attribute.GetNamingConvention();
object value;
try
{
value = Deserialize(textAsset.text, type, namingConvention);
}
catch (YamlException e)
{
var error = new AssetValidationErrors
{
AssetPath = assetPath,
TextAsset = textAsset,
Error = $"[{route.Group}]: {System.IO.Path.GetFileName(assetPath)} has syntax errors from {e.Start} to {e.End}"
};
if (e.InnerException != null)
{
error.Error += $"\n\r{e.InnerException.Message}";
}
errors.Add(error);
continue;
}
values[textAsset] = value;
}
else
{
errors.Add(new AssetValidationErrors
{
AssetPath = assetPath,
Error = $"[{route.Group}]: Failed to load TextAsset on path {assetPath}"
});
}
}
switch (route.Attribute.GetDeclarationType())
{
case DeclarationType.Single:
if (values.Count == 1)
{
result.StoredValue = values.SingleOrDefault().Value;
}
break;
case DeclarationType.List:
if (route.IsSingleFile)
{
var list = values.Values.SingleOrDefault() as IEnumerable <object>;
if (list != null)
{
result.StoredValue = ConvertList(list, route.RootType);
}
}
else
{
result.StoredValue = ConvertList(values.Values, route.RootType);
}
break;
case DeclarationType.Dictionary:
var methodInfo = route.KeySourceMethodInfo;
var assetsByKey = new Dictionary <object, List <TextAsset> >();
var pairs = new List <KeyValuePair <object, object> >();
var getKeyFunc = GetGetKeyFunc(route, methodInfo);
if (route.IsSingleFile)
{
var dictionaryAttribute = (AssetDictionaryAttribute)route.Attribute;
var dictionary = values.SingleOrDefault().Value;
if (dictionary != null)
{
result.StoredValue = ConvertDictionary(dictionary, dictionaryAttribute.KeyType, route.RootType);
}
}
else
{
foreach (var p in values)
{
var v = p.Value;
var k = getKeyFunc(methodInfo, v, p.Key);
if (k == null)
{
errors.Add(new AssetValidationErrors
{
TextAsset = p.Key,
AssetPath = p.Key.GetAssetPath(),
Error = $"[{route.Group}]: Asset {p.Key.name} dictionary key is invalid!"
});
continue;
}
Add(assetsByKey, k, p.Key);
pairs.Add(new KeyValuePair <object, object>(k, v));
}
result.StoredValue = ConvertDictionary(pairs, methodInfo.ReturnType, route.RootType);;
}
foreach (var pair in assetsByKey)
{
if (pair.Value == null ||
pair.Value.Count <= 1)
{
continue;
}
foreach (var asset in pair.Value)
{
errors.Add(new AssetValidationErrors
{
TextAsset = asset,
AssetPath = asset.GetAssetPath(),
Error = $"[{route.Group}]: {asset.name} contains duplicate dictionary key {pair.Key}! This will result in keys override and errors!"
});
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
return(result);
}
