protected override void AddBindable <TBindable>(TLookup lookup, Bindable <TBindable> bindable) { base.AddBindable(lookup, bindable); var setting = databasedSettings.Find(s => s.Key == lookup.ToString()); if (setting != null) { bindable.Parse(setting.Value); } else { setting = new RealmRulesetSetting { Key = lookup.ToString(), Value = bindable.Value.ToString(), RulesetID = rulesetId, Variant = variant, }; realmFactory?.Context.Write(() => realmFactory.Context.Add(setting)); databasedSettings.Add(setting); } bindable.ValueChanged += b => { realmFactory?.Context.Write(() => setting.Value = b.NewValue.ToString()); }; }
private IBindable <TValue>?genericLookup <TLookup, TValue>(TLookup lookup) where TLookup : notnull where TValue : notnull { try { if (Configuration.ConfigDictionary.TryGetValue(lookup.ToString(), out string val)) { // special case for handling skins which use 1 or 0 to signify a boolean state. if (typeof(TValue) == typeof(bool)) { val = val == "1" ? "true" : "false"; } var bindable = new Bindable <TValue>(); if (val != null) { bindable.Parse(val); } return(bindable); } } catch { } return(null); }
protected override void AddBindable <TBindable>(T lookup, Bindable <TBindable> bindable) { base.AddBindable(lookup, bindable); var setting = databasedSettings.Find(s => (int)s.Key == (int)(object)lookup); if (setting != null) { bindable.Parse(setting.Value); } else { settings.Update(setting = new DatabasedSetting { Key = lookup, Value = bindable.Value, RulesetID = ruleset?.ID, Variant = variant, }); databasedSettings.Add(setting); } bindable.ValueChanged += b => { setting.Value = b.NewValue; settings.Update(setting); }; }
protected override void AddBindable <TBindable>(TLookup lookup, Bindable <TBindable> bindable) { base.AddBindable(lookup, bindable); var setting = databasedSettings.Find(s => s.Key == lookup.ToString()); if (setting != null) { bindable.Parse(setting.Value); } else { setting = new RealmRulesetSetting { Key = lookup.ToString(), Value = bindable.Value.ToString(), RulesetName = rulesetName, Variant = variant, }; realm?.Realm.Write(() => realm.Realm.Add(setting)); databasedSettings.Add(setting); } bindable.ValueChanged += b => { lock (pendingWrites) pendingWrites.Add(lookup); }; }
private IBindable <TValue>?genericLookup <TLookup, TValue>(TLookup lookup) where TLookup : notnull where TValue : notnull { try { if (Configuration.ConfigDictionary.TryGetValue(lookup.ToString(), out string val)) { // special case for handling skins which use 1 or 0 to signify a boolean state. // ..or in some cases 2 (https://github.com/ppy/osu/issues/18579). if (typeof(TValue) == typeof(bool)) { val = bool.TryParse(val, out bool boolVal) ? Convert.ChangeType(boolVal, typeof(bool)).ToString() : Convert.ChangeType(Convert.ToInt32(val), typeof(bool)).ToString(); } var bindable = new Bindable <TValue>(); if (val != null) { bindable.Parse(val); } return(bindable); } } catch { } return(null); }
protected override void AddBindable <TBindable>(T lookup, Bindable <TBindable> bindable) { base.AddBindable(lookup, bindable); if (legacySettingsExist) { var legacySetting = databasedSettings.Find(s => s.Key == ((int)(object)lookup).ToString()); if (legacySetting != null) { bindable.Parse(legacySetting.Value); settings.Delete(legacySetting); } } var setting = databasedSettings.Find(s => s.Key == lookup.ToString()); if (setting != null) { bindable.Parse(setting.Value); } else { settings.Update(setting = new DatabasedSetting { Key = lookup.ToString(), Value = bindable.Value, RulesetID = ruleset?.ID, Variant = variant, }); databasedSettings.Add(setting); } bindable.ValueChanged += b => { setting.Value = b.NewValue; lock (dirtySettings) { if (!dirtySettings.Contains(setting)) { dirtySettings.Add(setting); } } }; }
public void TestParsingString(string value) { var bindable = new Bindable <string>(); bindable.Parse(value); Assert.AreEqual(value, bindable.Value); }
public void TestParsingEnumToNullableType(TestEnum value) { var bindable = new Bindable <TestEnum?>(); bindable.Parse(value); Assert.AreEqual(value, bindable.Value); }
public void TestParsingStringToNullableType(string value, TestEnum?expected) { var bindable = new Bindable <TestEnum?>(); bindable.Parse(value); Assert.AreEqual(expected, bindable.Value); }
public void TestUnparsaebles(object value) { var bindable = new Bindable <TestEnum>(); var nullable = new Bindable <TestEnum?>(); Assert.Throws <ArgumentException>(() => bindable.Parse(value)); Assert.Throws <ArgumentException>(() => nullable.Parse(value)); }
public void TestParsing(TestEnum expected, params object[] values) { var bindable = new Bindable <TestEnum>(); var nullable = new Bindable <TestEnum?>(); foreach (object value in values.Append(expected)) { bindable.Parse(value); nullable.Parse(value); Assert.AreEqual(expected, bindable.Value); Assert.AreEqual(expected, nullable.Value); } }
public void TestParseBindableOfMatchingInterfaceType() { // both of these implement IBindable<int> var bindable1 = new BindableInt(10) { MaxValue = 15 }; var bindable2 = new Bindable <int>(20); bindable1.Parse(bindable2); // ensure MaxValue is still respected. Assert.That(bindable1.Value, Is.EqualTo(15)); bindable2.Parse(bindable1); Assert.That(bindable2.Value, Is.EqualTo(15)); }
public override IBindable <TValue> GetConfig <TLookup, TValue>(TLookup lookup) { switch (lookup) { case GlobalSkinConfiguration global: switch (global) { case GlobalSkinConfiguration.ComboColours: return(SkinUtils.As <TValue>(new Bindable <List <Color4> >(Configuration.ComboColours))); } break; case GlobalSkinColour colour: return(SkinUtils.As <TValue>(getCustomColour(colour.ToString()))); case SkinCustomColourLookup customColour: return(SkinUtils.As <TValue>(getCustomColour(customColour.Lookup.ToString()))); default: try { if (Configuration.ConfigDictionary.TryGetValue(lookup.ToString(), out var val)) { // special case for handling skins which use 1 or 0 to signify a boolean state. if (typeof(TValue) == typeof(bool)) { val = val == "1" ? "true" : "false"; } var bindable = new Bindable <TValue>(); if (val != null) { bindable.Parse(val); } return(bindable); } } catch { } break; } return(null); }
public void TestParseBindableOfExactSameType() { var bindable1 = new BindableInt(); var bindable2 = new BindableDouble(); var bindable3 = new BindableBool(); var bindable4 = new Bindable <string>(); bindable1.Parse(new BindableInt(3)); bindable2.Parse(new BindableDouble(2.5)); bindable3.Parse(new BindableBool(true)); bindable4.Parse(new Bindable <string>("string value")); Assert.That(bindable1.Value, Is.EqualTo(3)); Assert.That(bindable2.Value, Is.EqualTo(2.5)); Assert.That(bindable3.Value, Is.EqualTo(true)); Assert.That(bindable4.Value, Is.EqualTo("string value")); // parsing bindable of different type should throw exception. Assert.Throws <ArgumentException>(() => bindable1.Parse(new BindableDouble(3.0))); }