public virtual void VerifyAssets(SheetConvertingContext context) { using (context.Logger.BeginScope(Index)) { SheetUtility.VerifyAssets(context, this); } }
public virtual void PostLoad(SheetConvertingContext context) { using (context.Logger.BeginScope(Index)) { SheetUtility.MapReferences(context, this); } }
public virtual void PostLoad() { var context = new SheetConvertingContext { Container = this, Logger = _logger, }; foreach (var prop in GetSheetProperties()) { var sheet = prop.GetValue(this) as ISheet; if (sheet == null) { continue; } sheet.Name = prop.Name; } foreach (var prop in GetSheetProperties()) { var sheet = prop.GetValue(this) as ISheet; if (sheet == null) { continue; } sheet.PostLoad(context); } }
protected virtual void PostLoad(SheetConvertingContext context) { foreach (var sheet in AllSheets) { sheet.PostLoad(context); } }
public async Task <bool> Import(SheetConvertingContext context) { var sheetProps = context.Container.GetSheetProperties(); foreach (var prop in sheetProps) { var path = Path.Combine(_loadPath, $"{prop.Name}.{Extension}"); if (!_fileSystem.Exists(path)) { context.Logger.LogError("Failed to find sheet: {SheetName}", prop.Name); continue; } string data; using (var stream = _fileSystem.OpenRead(path)) using (var reader = new StreamReader(stream)) data = await reader.ReadToEndAsync(); var sheet = Deserialize(data, prop.PropertyType, context.Logger) as ISheet; prop.SetValue(context.Container, sheet); } return(true); }
public static void ConvertFromRaw(SheetConvertingContext context, object obj, Dictionary <string, string> row) { var type = obj.GetType(); var bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty; var parentTag = context.Tag; foreach (var item in row) { var prop = type.GetProperty(item.Key, bindingFlags); if (prop == null) { continue; } context.SetTag(parentTag, item.Key); try { object value = ConvertValue(context, prop.PropertyType, item.Value); prop.SetValue(obj, value); } catch (Exception ex) { context.Logger.LogError($"[{context.Tag}] Failed to convert value \"{item.Value}\" of type {prop.PropertyType}\n{ex}"); } } }
public static void VerifyAssets(SheetConvertingContext context, object obj) { var assetProps = obj.GetType() .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(p => p.GetCustomAttribute(typeof(SheetAssetAttribute)) != null); foreach (var prop in assetProps) { using (context.Logger.BeginScope(prop.Name)) { foreach (var verifier in context.Verifiers) { if (!verifier.TargetType.IsAssignableFrom(prop.PropertyType)) { continue; } foreach (var att in prop.GetCustomAttributes(verifier.TargetAttribute)) { var err = verifier.Verify(att, prop.GetValue(obj)); if (err != null) { context.Logger.LogError("Verification: {Error}", err); } } } } } }
public virtual void VerifyAssets(SheetConvertingContext context) { using (context.Logger.BeginScope(Name)) { foreach (var row in Items) { row.VerifyAssets(context); } } }
public virtual void PostLoad(SheetConvertingContext context) { using (context.Logger.BeginScope(Name)) { foreach (var row in Items) { row.PostLoad(context); } } }
public async Task <bool> Store(ISheetExporter exporter) { var context = new SheetConvertingContext { Container = this, Logger = _logger, }; var success = await exporter.Export(context); return(success); }
public override void VerifyAssets(SheetConvertingContext context) { base.VerifyAssets(context); using (context.Logger.BeginScope(Id)) { for (int idx = 0; idx < Arr.Count; ++idx) { Arr[idx].VerifyAssets(context); } } }
public override void VerifyAssets(SheetConvertingContext context) { base.VerifyAssets(context); var parentTag = context.Tag; for (int idx = 0; idx < Arr.Count; ++idx) { context.SetTag(parentTag, Id); Arr[idx].VerifyAssets(context); } }
public override void PostLoad(SheetConvertingContext context) { base.PostLoad(context); using (context.Logger.BeginScope(Id)) { for (int idx = 0; idx < Arr.Count; ++idx) { Arr[idx].Index = idx; Arr[idx].PostLoad(context); } } }
public virtual void Verify(params SheetVerifier[] verifiers) { var context = new SheetConvertingContext { Container = this, Logger = _logger, Verifiers = verifiers }; foreach (var sheet in AllSheets) { sheet.VerifyAssets(context); } }
public override void PostLoad(SheetConvertingContext context) { base.PostLoad(context); var parentTag = context.Tag; for (int idx = 0; idx < Arr.Count; ++idx) { context.SetTag(parentTag, Id); Arr[idx].Index = idx; Arr[idx].PostLoad(context); } }
void ISheetReference.Map(SheetConvertingContext context) { var sheet = context.Container.AllSheets .FirstOrDefault(x => x.GetType().IsSubclassOf(typeof(Sheet <TKey, TValue>))); if (sheet != null) { Ref = (sheet as Sheet <TKey, TValue>)[Id]; } if (Id != null && Ref == null) { context.Logger.LogError($"[{context.Tag}] Failed to find reference \"{Id}\" on {sheet.Name}"); } }
public static void MapReferences(SheetConvertingContext context, object obj) { var refProps = obj.GetType() .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(p => typeof(ISheetReference).IsAssignableFrom(p.PropertyType)); foreach (var prop in refProps) { using (context.Logger.BeginScope(prop.Name)) { var refer = prop.GetValue(obj) as ISheetReference; refer.Map(context); prop.SetValue(obj, refer); } } }
void ISheetReference.Map(SheetConvertingContext context) { var sheet = context.Container.GetSheetProperties() .Where(p => p.PropertyType.IsSubclassOf(typeof(Sheet <TKey, TValue>))) .Select(p => p.GetValue(context.Container) as Sheet <TKey, TValue>) .FirstOrDefault(); if (sheet != null) { Ref = sheet[Id]; } if (Id != null && Ref == null) { context.Logger.LogError("Failed to find reference \"{ReferenceId}\" on {SheetName}", Id, sheet.Name); } }
public override void ConvertFromRaw(SheetConvertingContext context, RawSheetRow row) { base.ConvertFromRaw(context, row); Arr = new List <TElem>(); var parentTag = context.Tag; foreach (var item in row) { context.SetTag(parentTag, Id, Arr.Count); var elem = new TElem(); SheetUtility.ConvertFromRaw(context, elem, item); Arr.Add(elem); } }
public async Task Load(string loadPath, string ext = "json", Func <string, string> processor = null) { var sheetProps = GetType() .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(p => p.PropertyType.IsSubclassOf(typeof(Sheet))); var deserializeMethod = typeof(SheetUtility).GetMethod( nameof(SheetUtility.Deserialize), BindingFlags.Public | BindingFlags.Static); AllSheets.Clear(); var context = new SheetConvertingContext { Container = this, Logger = _logger, }; foreach (var prop in sheetProps) { string data; var path = Path.Combine(loadPath, $"{prop.Name}.{ext}"); using (var file = File.OpenText(path)) data = await file.ReadToEndAsync(); if (processor != null) { data = processor(data); } var genericMethod = deserializeMethod.MakeGenericMethod(prop.PropertyType); var sheet = genericMethod.Invoke(null, new object[] { data, _logger }) as Sheet; prop.SetValue(this, sheet); if (sheet != null) { sheet.Name = prop.Name; AllSheets.Add(sheet); } } PostLoad(context); IsLoaded = true; }
public async Task Bake(ISheetImporter importer, TimeZoneInfo timeZoneInfo) { AllSheets.Clear(); var context = new SheetConvertingContext { Container = this, Logger = _logger, TimeZoneInfo = timeZoneInfo }; var sheetProps = GetType() .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(p => p.PropertyType.IsSubclassOf(typeof(Sheet))); var success = await importer.Load(); if (!success) { _logger.LogError($"Failed to import"); return; } foreach (var prop in sheetProps) { var data = importer.GetData(prop.Name); if (data == null) { _logger.LogError($"Failed to find sheet: {prop.Name}"); continue; } var rawSheet = new RawSheet(data); var sheet = Activator.CreateInstance(prop.PropertyType) as Sheet; sheet.ConvertFromRaw(rawSheet, context); prop.SetValue(this, sheet); sheet.Name = prop.Name; AllSheets.Add(sheet); } PostLoad(context); IsLoaded = true; }
public async Task <bool> Export(SheetConvertingContext context) { var sheetProps = context.Container.GetSheetProperties(); foreach (var prop in sheetProps) { var sheet = prop.GetValue(context.Container); var data = Serialize(sheet, prop.PropertyType, context.Logger); var path = Path.Combine(_loadPath, $"{prop.Name}.{Extension}"); using (var stream = _fileSystem.OpenWrite(path)) using (var writer = new StreamWriter(stream)) await writer.WriteAsync(data); } return(true); }
public async Task <bool> Bake(ISheetImporter importer) { var context = new SheetConvertingContext { Container = this, Logger = _logger, }; var success = await importer.Import(context); if (!success) { return(false); } PostLoad(); return(true); }
public virtual void Verify(params SheetVerifier[] verifiers) { var context = new SheetConvertingContext { Container = this, Logger = _logger, Verifiers = verifiers }; foreach (var prop in GetSheetProperties()) { var sheet = prop.GetValue(this) as ISheet; if (sheet == null) { continue; } sheet.VerifyAssets(context); } }
public static object ConvertValue(SheetConvertingContext context, Type type, string value) { if (type.IsEnum) { return(Enum.Parse(type, value)); } if (typeof(ISheetReference).IsAssignableFrom(type)) { var targetType = type.GetInterfaces() .Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ISheetReference <>)) .Select(x => x.GetGenericArguments()[0]) .First(); return(Activator.CreateInstance(type, ConvertValue(context, targetType, value))); } if (typeof(DateTime).IsAssignableFrom(type)) { var local = DateTime.Parse(value); return(TimeZoneInfo.ConvertTimeToUtc(local, context.TimeZoneInfo)); } if (typeof(TimeSpan).IsAssignableFrom(type)) { return(TimeSpan.Parse(value)); } if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { if (string.IsNullOrEmpty(value)) { return(null); } var underlyingType = Nullable.GetUnderlyingType(type); return(ConvertValue(context, underlyingType, value)); } return(Convert.ChangeType(value, type)); }
public abstract void VerifyAssets(SheetConvertingContext context);
public abstract void PostLoad(SheetConvertingContext context);
internal abstract void ConvertFromRaw(RawSheet gsheet, SheetConvertingContext context);
public virtual void VerifyAssets(SheetConvertingContext context) { context.SetTag(context.Tag, Index); SheetUtility.VerifyAssets(context, this); }
public virtual void PostLoad(SheetConvertingContext context) { context.SetTag(context.Tag, Index); SheetUtility.MapReferences(context, this); }