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); }