public IEnumerable <T> ParseParallel( MutagenFrame frame, RecordType triggeringRecord, BinaryMasterParseDelegate <T> transl, RecordTypeConverter?recordTypeConverter = null) { var frames = new List <MutagenFrame>(); triggeringRecord = recordTypeConverter.ConvertToCustom(triggeringRecord); while (!frame.Complete && !frame.Reader.Complete) { var header = frame.MetaData.Constants.GetNextRecordVariableMeta(frame.Reader); if (header.RecordType != triggeringRecord) { break; } if (!IsLoqui) { throw new NotImplementedException(); } var totalLen = header.TotalLength; var subFrame = new MutagenFrame(frame.ReadAndReframe(checked ((int)totalLen))); frames.Add(subFrame); } var ret = new TryGet <T> [frames.Count]; Parallel.ForEach(frames, (subFrame, state, count) => { if (transl(subFrame, out var subItem, recordTypeConverter)) { ret[count] = TryGet <T> .Succeed(subItem); }
public InternalImmutableLoadOrderLinkCache( IEnumerable <IModGetter> loadOrder, GameCategory gameCategory, bool hasAny, bool simple, LinkCachePreferences?prefs) { prefs ??= LinkCachePreferences.Default; _listedOrder = loadOrder.ToList(); _priorityOrder = _listedOrder.Reverse().ToList(); _formKeyCache = new ImmutableLoadOrderLinkCacheCategory <FormKey>( gameCategory, hasAny: hasAny, simple: simple, listedOrder: _listedOrder, m => TryGet <FormKey> .Succeed(m.FormKey), f => f.IsNull); this._editorIdCache = new ImmutableLoadOrderLinkCacheCategory <string>( gameCategory, hasAny: hasAny, simple: simple, listedOrder: _listedOrder, m => { var edid = m.EditorID; return(TryGet <string> .Create(successful: !string.IsNullOrWhiteSpace(edid), edid !)); },
public ImmutableModLinkCache(IModGetter sourceMod, LinkCachePreferences?prefs = null) { _sourceMod = sourceMod; var simple = prefs is LinkCachePreferenceOnlyIdentifiers; var category = sourceMod.GameRelease.ToCategory(); _cache = new InternalImmutableModLinkCache(sourceMod, prefs); _formKeyContexts = new ImmutableModLinkCacheSimpleContextCategory <FormKey>( simple: simple, linkCache: this, category: category, contextEnumerable: sourceMod, keyGetter: m => TryGet <FormKey> .Succeed(m.FormKey), shortCircuit: f => f.IsNull); _editorIdContexts = new ImmutableModLinkCacheSimpleContextCategory <string>( simple: simple, linkCache: this, category: category, contextEnumerable: sourceMod, keyGetter: m => { var edid = m.EditorID; return(TryGet <string> .Create(successful: !string.IsNullOrWhiteSpace(edid), edid !)); }, shortCircuit: e => e.IsNullOrWhitespace()); }
public static EnumerableStringSettingsVM Factory(FieldMeta fieldMeta, object?defaultVal) { Func <JsonElement, TryGet <IBasicSettingsNodeVM> > import = new((elem) => { return(TryGet <IBasicSettingsNodeVM> .Succeed( new ListElementWrapperVM <string, StringSettingsVM>( new StringSettingsVM() { Value = elem.GetString() ?? string.Empty }))); }); return(new EnumerableStringSettingsVM( fieldMeta, import, (list) => { list.Add(new ListElementWrapperVM <string, StringSettingsVM>(new StringSettingsVM() { Value = string.Empty }) { IsSelected = true }); }, defaultVal as IEnumerable <string> ?? Enumerable.Empty <string>())); }
/// <summary> /// Converts a stardard tryer function (like int.TryParse, Dictionary.TryGetValue etc.) to a function, returning Maybe /// </summary> /// <typeparam name="TR"></typeparam> /// <typeparam name="T"></typeparam> /// <param name="tryer"></param> /// <returns></returns> public static Func <T, Maybe <TR> > Wrap <T, TR>(TryGet <T, TR> tryer) => (T arg) => { TR result; return(tryer(arg, out result) ? result.ToMaybe() : Maybe <TR> .Nothing); };
static void Run(TryGet <string, int> askUser, Action <string> tellUser) { int age; if (askUser("What is your age?", tellUser, out age)) { tellUser("Age: " + age); } }
private static TryGet <string> AdditionalParam( ObjectGeneration objGen, TypeGeneration typeGen) { var binaryType = BinaryType(typeGen); string param = $"binaryType: {nameof(ColorBinaryType)}.{binaryType}"; return(TryGet <string> .Create(successful : binaryType != ColorBinaryType.Alpha, val : param)); }
public static async Task <TryGet <IEnumerable <RecordType> > > TryGetTriggeringRecordTypes(this ObjectGeneration objGen) { await objGen.LoadingCompleteTask.Task; var data = objGen.GetObjectData(); return(TryGet <IEnumerable <RecordType> > .Create( successful : data.TriggeringRecordTypes.Any(), val : data.TriggeringRecordTypes)); }
public static TryGet <object> Instantiate(string name, object[] args) { TryGet <Type> tGet = TryGetType(name); if (tGet.Failed) { return(tGet.BubbleFailure <object>()); } return(TryGet <object> .Succeed(Activator.CreateInstance(tGet.Value, args))); }
public async Task <TryGet <T> > Parse( MutagenFrame frame, RecordTypeConverter?recordTypeConverter) { var item = await CREATE( reader : frame, recordTypeConverter : recordTypeConverter).ConfigureAwait(false); return(TryGet <T> .Succeed(item)); }
public async Task <TryGet <T> > Parse( MutagenFrame frame, TypedParseParams?parseParams) { var item = await CREATE( reader : frame, parseParams : parseParams).ConfigureAwait(false); return(TryGet <T> .Succeed(item)); }
public static IMaybe <TR> Wrap <T, TR>(TryGet <T, TR> tryer, T value) { Debug.Assert(tryer != null); TR result; return(tryer(value, out result) ? result.ToMaybe() : Maybe <TR> .None); }
/// <summary> /// Converts a stardard tryer function (like int.TryParse, Dictionary.TryGetValue etc.) to a function, returning Maybe /// </summary> /// <typeparam name="TR"></typeparam> /// <typeparam name="T"></typeparam> /// <param name="tryer"></param> /// <returns></returns> public static Func <T, Maybe <TR> > Wrap <T, TR>(TryGet <T, TR> tryer) { return(s => { TR result; return tryer(s, out result) ? result.ToMaybe() : Maybe <TR> .Nothing; }); }
public static IObservable <IChangeSet <LoadOrderListing> > GetLiveLoadOrder( FilePath cccFilePath, DirectoryPath dataFolderPath, out IObservable <ErrorResponse> state, bool orderListings = true) { var raw = ObservableExt.WatchFile(cccFilePath.Path) .StartWith(Unit.Default) .Select(_ => { try { return(GetResponse <IObservable <IChangeSet <ModKey> > > .Succeed( File.ReadAllLines(cccFilePath.Path) .Select(x => ModKey.FromNameAndExtension(x)) .AsObservableChangeSet())); } catch (Exception ex) { return(GetResponse <IObservable <IChangeSet <ModKey> > > .Fail(ex)); } }) .Replay(1) .RefCount(); state = raw .Select(r => (ErrorResponse)r); var ret = ObservableListEx.And( raw .Select(r => { return(r.Value ?? Observable.Empty <IChangeSet <ModKey> >()); }) .Switch(), ObservableExt.WatchFolderContents(dataFolderPath.Path) .Transform(x => { if (ModKey.TryFromNameAndExtension(Path.GetFileName(x), out var modKey)) { return(TryGet <ModKey> .Succeed(modKey)); } return(TryGet <ModKey> .Failure); }) .Filter(x => x.Succeeded) .Transform(x => x.Value) .RemoveKey()) .Transform(x => new LoadOrderListing(x, true)); if (orderListings) { ret = ret.OrderListings(); } return(ret); }
private static TryGet <string> AdditionalParam( ObjectGeneration objGen, TypeGeneration typeGen) { var floatType = typeGen as Mutagen.Bethesda.Generation.FloatType; if (floatType.IntegerType == null && !floatType.Multiplier.EqualsWithin(1)) { return(TryGet <string> .Succeed($"multiplier: {(float)floatType.Multiplier}f")); } return(TryGet <string> .Failure); }
public TryGet <string> Parse(XElement root, bool doMasks, out object maskObj) { if (!root.Name.LocalName.Equals(ElementName)) { maskObj = new ArgumentException($"Skipping field Version that did not match proper type. Type: {root.Name.LocalName}, expected: {ElementName}."); return(TryGet <string> .Failure); } maskObj = null; if (root.TryGetAttribute(XmlConstants.VALUE_ATTRIBUTE, out XAttribute val)) { return(TryGet <string> .Succeed(val.Value)); } return(TryGet <string> .Succeed(null)); }
public ImmutableModLinkCache(IModGetter sourceMod, LinkCachePreferences?prefs = null) { _sourceMod = sourceMod; Category = sourceMod.GameRelease.ToCategory(); _simple = prefs is LinkCachePreferenceOnlyIdentifiers; _formKeyCache = new ImmutableModLinkCacheCategory <FormKey>( this, x => TryGet <FormKey> .Succeed(x.FormKey), x => x.IsNull); _editorIdCache = new ImmutableModLinkCacheCategory <string>( this, m => { var edid = m.EditorID; return(TryGet <string> .Create(successful: !string.IsNullOrWhiteSpace(edid), edid !)); },
public static void WriteToFile(string path, IModGetter mod) { WriteToFile( path, mod.NextFormID, mod.EnumerateMajorRecords() .SelectWhere(m => { var edid = m.EditorID; if (edid == null) { return(TryGet <KeyValuePair <string, FormKey> > .Failure); } return(TryGet <KeyValuePair <string, FormKey> > .Succeed( new KeyValuePair <string, FormKey>(edid, m.FormKey))); })); }
public static TryGet <Type> TryGetType(string name) { if (!cache.TryGetValue(name, out Type t)) { try { TypeStringNode node = Parse(name); throw new NotImplementedException(); } catch { cache[name] = null; return(TryGet <Type> .Failure); } } return(TryGet <Type> .Create(t != null, t)); }
public EnumerableFormKeySettingsVM( FieldMeta fieldMeta, IEnumerable <FormKey> defaultVal) : base( fieldMeta, get: e => TryGet <IBasicSettingsNodeVM> .Succeed( new ListElementWrapperVM <FormKey, FormKeySettingsVM>(new FormKeySettingsVM() { Value = FormKeySettingsVM.Import(e) })), add: coll => coll.Add(new ListElementWrapperVM <FormKey, FormKeySettingsVM>(new FormKeySettingsVM() { Value = FormKey.Null }) { IsSelected = true })) { _defaultVal = defaultVal.ToArray(); }
public static EnumerableNumericSettingsVM Factory <TItem, TWrapper>(FieldMeta fieldMeta, object?defaultVal, TWrapper prototype) where TWrapper : BasicSettingsVM <TItem>, new() { Func <JsonElement, TryGet <IBasicSettingsNodeVM> > import = new((elem) => { return(TryGet <IBasicSettingsNodeVM> .Succeed( new ListElementWrapperVM <TItem, TWrapper>( new TWrapper() { Value = prototype.Get(elem) }))); }); return(new EnumerableNumericSettingsVM( fieldMeta, import, (list) => { list.Add(new ListElementWrapperVM <TItem, TWrapper>(new TWrapper() { Value = prototype.GetDefault() }) { IsSelected = true }); }, (list, def) => { if (def is IEnumerable <TItem> items) { list.SetTo(items.Select(x => { return new ListElementWrapperVM <TItem, TWrapper>(new TWrapper() { Value = x }); })); } }, defaultVal)); }
public IObservable <IChangeSet <ModKey, ModKey> > Get() { if (!_fileSystem.Directory.Exists(DataDirectory.Path)) { return(Observable.Empty <IChangeSet <ModKey, ModKey> >()); } return(ObservableExt .WatchFolderContents(DataDirectory.Path, fileSystem: _fileSystem) .Transform(x => { if (ModKey.TryFromNameAndExtension(Path.GetFileName(x), out var modKey)) { return TryGet <ModKey> .Succeed(modKey); } return TryGet <ModKey> .Failure; }) .Filter(x => x.Succeeded) .Transform(x => x.Value) .ChangeKey(x => x) .Catch <IChangeSet <ModKey, ModKey>, DirectoryNotFoundException>(_ => Observable.Empty <IChangeSet <ModKey, ModKey> >())); }
public BooleanBinaryTranslationGeneration() : base(expectedLen: 1) { this.AdditionalCopyInParams.Add((o, t) => { BoolType b = t as BoolType; if (b.ByteLength != 1) { return(TryGet <string> .Succeed($"byteLength: {b.ByteLength}")); } return(TryGet <string> .Failure); }); this.AdditionalWriteParams.Add((o, t) => { BoolType b = t as BoolType; if (b.ByteLength != 1) { return(TryGet <string> .Succeed($"byteLength: {b.ByteLength}")); } return(TryGet <string> .Failure); }); }
private TryGet <T?> Parse_Internal(XElement root, bool nullable, bool doMasks, out object maskObj) { if (!root.Name.LocalName.Equals(nullable ? ElementName : NullLessName)) { var ex = new ArgumentException($"Skipping field Version that did not match proper type. Type: {root.Name.LocalName}, expected: {ElementName}."); if (doMasks) { maskObj = ex; return(TryGet <T?> .Failure); } else { throw ex; } } maskObj = null; if (!root.TryGetAttribute(XmlConstants.VALUE_ATTRIBUTE, out XAttribute val) || string.IsNullOrEmpty(val.Value)) { return(TryGet <T?> .Succeed(null)); } return(TryGet <T?> .Succeed(ParseNonNullString(val.Value))); }
public void CanSerializeMemberMethod1() { TryGet tryGet = TryGetImpl; var bytes = MessagePackSerializer.Serialize(tryGet, DefaultResolver.Instance); var res = MessagePackSerializer.Deserialize <TryGet>(bytes, DefaultResolver.Instance); Assert.NotNull(res); var key = 1; Assert.True(res(key, out var value)); Assert.Equal(2, value); TransIndex trans = TransIndexImpl; bytes = MessagePackSerializer.Serialize(trans, DefaultResolver.Instance); var res1 = MessagePackSerializer.Deserialize <TransIndex>(bytes, DefaultResolver.Instance); Assert.NotNull(res1); var idx = 1; res1(ref idx); Assert.Equal(11, idx); }
public ImmutableLoadOrderLinkCache( IEnumerable <IModGetter> loadOrder, GameCategory?gameCategory, LinkCachePreferences?prefs) { var loadOrderArr = loadOrder.ToArray(); var firstMod = loadOrderArr.FirstOrDefault(); _hasAny = firstMod != null; var simple = prefs is LinkCachePreferenceOnlyIdentifiers; gameCategory ??= firstMod?.GameRelease.ToCategory() ?? throw new ArgumentException($"Could not get {nameof(GameCategory)} via generic type or first mod"); _cache = new InternalImmutableLoadOrderLinkCache( loadOrderArr, gameCategory.Value, hasAny: _hasAny, simple: simple, prefs); _formKeyContexts = new ImmutableLoadOrderLinkCacheSimpleContextCategory <FormKey>( gameCategory.Value, simple: simple, hasAny: _hasAny, this, loadOrderArr, m => TryGet <FormKey> .Succeed(m.FormKey), f => f.IsNull); _editorIdContexts = new ImmutableLoadOrderLinkCacheSimpleContextCategory <string>( gameCategory.Value, simple: simple, hasAny: _hasAny, this, loadOrderArr, m => { var edid = m.EditorID; return(TryGet <string> .Create(successful: !string.IsNullOrWhiteSpace(edid), edid !)); },
TryGet <T> IXmlTranslation <T> .Parse(XElement root, bool doMasks, out object maskObj) { var parse = this.Parse_Internal(root, nullable: false, doMasks: doMasks, maskObj: out maskObj); if (parse.Failed) { return(parse.BubbleFailure <T>()); } if (parse.Value.HasValue) { return(TryGet <T> .Succeed(parse.Value.Value)); } var ex = new ArgumentException("Value was unexpectedly null."); if (doMasks) { maskObj = ex; return(TryGet <T> .Failure); } else { throw ex; } }
public TryGet <IEnumerable <T> > Parse(XElement root, bool doMasks, out object maskObj) { return(TryGet <IEnumerable <T> > .Succeed(Parse_Internal(root, doMasks, out maskObj))); }
public TryGet <string> FlipTest(ObjectGeneration o, TypeGeneration t) { return(TryGet <string> .Create(NeedsFlip(t), "swapCoords: true")); }