public static SettingsNodeVM[] Factory(ReflectionSettingsParameters param)
{
return(GetMemberInfos(param)
.Select(m =>
{
try
{
var node = m switch
{
PropertyInfo prop => MemberFactory(param with
{
TargetType = prop.PropertyType,
DefaultVal = param.DefaultVal == null ? null : prop.GetValue(param.DefaultVal)
}, prop),
FieldInfo field => MemberFactory(param with
{
TargetType = field.FieldType,
DefaultVal = param.DefaultVal == null ? null : field.GetValue(param.DefaultVal)
}, field),
_ => throw new ArgumentException(),
};
return node;
}
catch (Exception ex)
{
throw new Exception($"{param.TargetType} failed to retrieve property {m}", ex);
}
})
.ToArray());
}
public static EnumerableObjectSettingsVM Factory(ReflectionSettingsParameters param, FieldMeta fieldMeta)
{
var proto = new ObjectSettingsVM(param with {
DefaultVal = null
}, FieldMeta.Empty with
{
Parent = fieldMeta.Parent,
MainVM = fieldMeta.MainVM,
IsPassthrough = true,
});
public ReflectionSettingsVM(ReflectionSettingsParameters param)
{
ObjVM = new ObjectSettingsVM(
param with
{
MainVM = this
},
FieldMeta.Empty with
{
DisplayName = "Top Level",
MainVM = this
});
public async Task <GetResponse <ReflectionSettingsBundleVm> > ExtractBundle(
string projPath,
ReflectionSettingsConfig[] targets,
IObservable <IChangeSet <IModListingGetter> > detectedLoadOrder,
IObservable <ILinkCache?> linkCache,
CancellationToken cancel)
{
var vms = await _Extract.Extract <ReflectionSettingsVM[]>(
projPath : projPath,
cancel : cancel,
getter : (assemb) =>
{
return(targets
.Select((s, index) =>
{
try
{
var t = assemb.GetType(s.TypeName);
if (t == null)
{
return null;
}
return _reflFactory(
ReflectionSettingsParameters.FromType(
detectedLoadOrder.ObserveOn(RxApp.MainThreadScheduler),
linkCache,
t,
Activator.CreateInstance(t)),
nickname: targets[index].Nickname,
settingsSubPath: targets[index].Path);
}
catch (Exception ex)
{
_Logger.Error(ex, "Error creating reflected settings");
throw new ArgumentException($"Error creating reflected settings: {ex.Message}");
}
})
.NotNull()
.ToArray());
}).ConfigureAwait(false);
if (vms.Failed)
{
return(vms.BubbleFailure <ReflectionSettingsBundleVm>());
}
await Task.WhenAll(vms.Value.Item.Select(vm => vm.Import(cancel))).ConfigureAwait(false);
return(new ReflectionSettingsBundleVm(vms.Value.Item, vms.Value.Temp, _Logger));
}
public ReflectionSettingsVM(
ReflectionSettingsParameters param,
string nickname,
IPatcherExtraDataPathProvider extraDataPathProvider,
string settingsSubPath,
ILogger logger,
IFileSystem fileSystem)
: base(param)
{
_extraDataPathProvider = extraDataPathProvider;
_logger = logger;
_fileSystem = fileSystem;
Nickname = nickname;
SettingsSubPath = settingsSubPath;
}
public static EnumerableModKeySettingsVM Factory(ReflectionSettingsParameters param, FieldMeta fieldMeta, object?defaultVal)
{
var defaultKeys = new List <ModKey>();
if (defaultVal is IEnumerable e)
{
foreach (var item in e)
{
defaultKeys.Add(ModKey.FromNameAndExtension(item.ToString()));
}
}
return(new EnumerableModKeySettingsVM(
param.DetectedLoadOrder.Transform(x => x.ModKey),
fieldMeta,
defaultKeys));
}
public static SettingsNodeVM Factory(ReflectionSettingsParameters param, FieldMeta fieldMeta, string typeName, object?defaultVal)
{
var defaultKeys = new List <FormKey>();
if (defaultVal is IEnumerable e)
{
var targetType = e.GetType().GenericTypeArguments[0];
var getter = targetType.GetPublicProperties().FirstOrDefault(m => m.Name == "FormKey") !;
foreach (var item in e)
{
defaultKeys.Add(FormKey.Factory(getter.GetValue(item) !.ToString()));
}
}
return(new EnumerableFormLinkSettingsVM(
param.LinkCache,
fieldMeta: fieldMeta,
typeName: typeName,
defaultKeys));
}
public static DictionarySettingsVM Factory(ReflectionSettingsParameters param, FieldMeta fieldMeta)
{
var vals = GetDefaultValDictionary(param.DefaultVal);
var proto = SettingsNodeVM.MemberFactory(param with {
DefaultVal = null
}, member: null);
proto.WrapUp();
return(new DictionarySettingsVM(
fieldMeta,
vals.Select(defVal =>
{
return new KeyValuePair <string, SettingsNodeVM>(
defVal.Key.ToString() !,
SettingsNodeVM.MemberFactory(param with {
DefaultVal = defVal.Value
}, member: null));
}).ToArray(),
prototype: proto));
}
public static IEnumerable <MemberInfo> GetMemberInfos(ReflectionSettingsParameters param)
{
return(param.TargetType.GetMembers()
.Where(m => m.MemberType == MemberTypes.Property ||
m.MemberType == MemberTypes.Field)
.Where(m =>
{
return m switch
{
PropertyInfo prop => !Noggog.MemberInfoExt.IsStatic(prop) && prop.GetSetMethod() != null,
FieldInfo field => !field.IsStatic && !field.IsInitOnly,
_ => true,
};
})
.Where(m => !m.TryGetCustomAttributeByName(nameof(Ignore), out var _))
.OrderBy(m =>
{
return m.GetCustomAttributeValueByName(nameof(MaintainOrder), nameof(MaintainOrder.Order), int.MaxValue);
}));
}
public MainVM()
{
var gameRelease = SkyrimRelease.SkyrimSE;
var env = GameEnvironment.Typical.Skyrim(gameRelease, LinkCachePreferences.OnlyIdentifiers())
.DisposeWith(this);
LinkCache = env.LinkCache;
LoadOrder = env.LoadOrder;
ScopedTypes = typeof(IArmorGetter).AsEnumerable();
LateSetPickerVM = new LateSetPickerVM(this);
Reflection = new ReflectionSettingsVM(
ReflectionSettingsParameters.CreateFrom(
new TestSettings(),
env.LoadOrder.ListedOrder,
env.LinkCache));
LoadOrderVM = new FileSyncedLoadOrderVM(env.LoadOrderFilePath)
{
DataFolderPath = env.DataFolderPath.Path,
CreationClubFilePath = env.CreationKitLoadOrderFilePath?.Path ?? string.Empty,
GameRelease = gameRelease.ToGameRelease(),
};
}
public static EnumDictionarySettingsVM Factory(ReflectionSettingsParameters param, FieldMeta fieldMeta, Type enumType)
{
var vals = GetDefaultValDictionary(param.DefaultVal);
var proto = SettingsNodeVM.MemberFactory(param with {
DefaultVal = null
}, member: null);
proto.WrapUp();
return(new EnumDictionarySettingsVM(
fieldMeta,
Enum.GetNames(enumType).Select(e =>
{
if (!vals.TryGetValue(e, out var defVal))
{
defVal = null;
}
return new KeyValuePair <string, SettingsNodeVM>(
e,
SettingsNodeVM.MemberFactory(param with {
DefaultVal = defVal
}, member: null));
}).ToArray(),
proto));
}
public static SettingsNodeVM MemberFactory(ReflectionSettingsParameters param, MemberInfo?member)
{
string displayName = GetDisplayName(member);
string diskName = GetDiskName(member);
string?tooltip = member?.GetCustomAttributeValueByName <string?>(nameof(Tooltip), nameof(Tooltip.Text), null);
var meta = new FieldMeta(
DisplayName: displayName,
DiskName: diskName,
Tooltip: tooltip,
MainVM: param.MainVM,
Parent: param.Parent,
IsPassthrough: false);
switch (param.TargetType.Name)
{
case "Boolean":
return(new BoolSettingsVM(meta, param.DefaultVal));
case "SByte":
return(new Int8SettingsVM(meta, param.DefaultVal));
case "Int16":
return(new Int16SettingsVM(meta, param.DefaultVal));
case "Int32":
return(new Int32SettingsVM(meta, param.DefaultVal));
case "Int64":
return(new Int64SettingsVM(meta, param.DefaultVal));
case "Byte":
return(new UInt8SettingsVM(meta, param.DefaultVal));
case "UInt16":
return(new UInt16SettingsVM(meta, param.DefaultVal));
case "UInt32":
return(new UInt32SettingsVM(meta, param.DefaultVal));
case "UInt64":
return(new UInt64SettingsVM(meta, param.DefaultVal));
case "Double":
return(new DoubleSettingsVM(meta, param.DefaultVal));
case "Single":
return(new FloatSettingsVM(meta, param.DefaultVal));
case "Decimal":
return(new DecimalSettingsVM(meta, param.DefaultVal));
case "String":
return(new StringSettingsVM(meta, param.DefaultVal));
case "ModKey":
return(new ModKeySettingsVM(param.DetectedLoadOrder.Transform(x => x.ModKey), meta, param.DefaultVal));
case "FormKey":
return(new FormKeySettingsVM(meta, param.DefaultVal));
case "Array`1":
case "List`1":
case "IEnumerable`1":
case "HashSet`1":
{
var firstGen = param.TargetType.GenericTypeArguments[0];
switch (firstGen.Name)
{
case "SByte":
return(EnumerableNumericSettingsVM.Factory <sbyte, Int8SettingsVM>(meta, param.DefaultVal, new Int8SettingsVM()));
case "Int16":
return(EnumerableNumericSettingsVM.Factory <short, Int16SettingsVM>(meta, param.DefaultVal, new Int16SettingsVM()));
case "Int32":
return(EnumerableNumericSettingsVM.Factory <int, Int32SettingsVM>(meta, param.DefaultVal, new Int32SettingsVM()));
case "Int64":
return(EnumerableNumericSettingsVM.Factory <long, Int64SettingsVM>(meta, param.DefaultVal, new Int64SettingsVM()));
case "Byte":
return(EnumerableNumericSettingsVM.Factory <byte, UInt8SettingsVM>(meta, param.DefaultVal, new UInt8SettingsVM()));
case "UInt16":
return(EnumerableNumericSettingsVM.Factory <ushort, UInt16SettingsVM>(meta, param.DefaultVal, new UInt16SettingsVM()));
case "UInt32":
return(EnumerableNumericSettingsVM.Factory <uint, UInt32SettingsVM>(meta, param.DefaultVal, new UInt32SettingsVM()));
case "UInt64":
return(EnumerableNumericSettingsVM.Factory <ulong, UInt64SettingsVM>(meta, param.DefaultVal, new UInt64SettingsVM()));
case "Double":
return(EnumerableNumericSettingsVM.Factory <double, DoubleSettingsVM>(meta, param.DefaultVal, new DoubleSettingsVM()));
case "Single":
return(EnumerableNumericSettingsVM.Factory <float, FloatSettingsVM>(meta, param.DefaultVal, new FloatSettingsVM()));
case "Decimal":
return(EnumerableNumericSettingsVM.Factory <decimal, DecimalSettingsVM>(meta, param.DefaultVal, new DecimalSettingsVM()));
case "ModKey":
return(EnumerableModKeySettingsVM.Factory(param, meta, param.DefaultVal));
case "FormKey":
return(EnumerableFormKeySettingsVM.Factory(meta, param.DefaultVal));
case "String":
return(EnumerableStringSettingsVM.Factory(meta, param.DefaultVal));
default:
{
if (firstGen.Name.Contains("FormLink") &&
firstGen.IsGenericType &&
firstGen.GenericTypeArguments.Length == 1)
{
var formLinkGen = firstGen.GenericTypeArguments[0];
return(EnumerableFormLinkSettingsVM.Factory(param, meta, formLinkGen.FullName ?? string.Empty, param.DefaultVal));
}
var foundType = param.Assembly.GetType(firstGen.FullName !);
if (foundType != null)
{
if (foundType.IsEnum)
{
return(EnumerableEnumSettingsVM.Factory(meta, param.DefaultVal, foundType));
}
else
{
return(EnumerableObjectSettingsVM.Factory(param with {
TargetType = foundType
}, meta));
}
}
return(new UnknownSettingsVM(meta));
}
}
}
case "Dictionary`2":
{
var firstGen = param.TargetType.GenericTypeArguments[0];
var secondGen = param.TargetType.GenericTypeArguments[1];
if (member != null &&
firstGen.IsEnum &&
(!member.TryGetCustomAttributeByName(nameof(StaticEnumDictionary), out var staticEnumAttr) ||
(staticEnumAttr.GetType().GetProperty(nameof(StaticEnumDictionary.Enabled)) is PropertyInfo staticEnumProp &&
(bool)staticEnumProp.GetValue(staticEnumAttr) !)))
{
return(EnumDictionarySettingsVM.Factory(param with {
TargetType = secondGen
}, meta, firstGen));
}
