protected bool TryFetch(OptionKey optionKey, Func<RegistryKey, string, IOption, object> valueGetter, out object value) { if (this.RegistryKey == null) { throw new InvalidOperationException(); } var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language); if (collectionPathAndPropertyName == null) { value = null; return false; } lock (Gate) { using (var subKey = this.RegistryKey.OpenSubKey(collectionPathAndPropertyName.Item1)) { if (subKey == null) { value = null; return false; } value = valueGetter(subKey, collectionPathAndPropertyName.Item2, optionKey.Option); return true; } } }
bool IOptionSerializer.TryFetch(OptionKey optionKey, out object value) { var collectionPath = GetCollectionPathForOption(optionKey); if (collectionPath == null) { value = null; return false; } lock (_gate) { using (var subKey = this._registryKey.OpenSubKey(collectionPath)) { if (subKey == null) { value = null; return false; } // Options that are of type bool have to be serialized as integers if (optionKey.Option.Type == typeof(bool)) { value = subKey.GetValue(optionKey.Option.Name, defaultValue: (bool)optionKey.Option.DefaultValue ? 1 : 0).Equals(1); return true; } else { // Otherwise we can just store normally value = subKey.GetValue(optionKey.Option.Name, defaultValue: optionKey.Option.DefaultValue); return true; } } } }
protected bool TryPersist(OptionKey optionKey, object value, Action<RegistryKey, string, IOption, object> valueSetter) { // We ignore languageName, since the current use of this class is only for // language-specific options that apply to a single language. The underlying option // service has already ensured the languageName is right, so we'll drop it on the floor. if (this.RegistryKey == null) { throw new InvalidOperationException(); } var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language); if (collectionPathAndPropertyName == null) { return false; } lock (Gate) { using (var subKey = this.RegistryKey.CreateSubKey(collectionPathAndPropertyName.Item1)) { valueSetter(subKey, collectionPathAndPropertyName.Item2, optionKey.Option, value); return true; } } }
protected override string GetCollectionPathForOption(OptionKey key) { if (key.Option.Feature == EditorComponentOnOffOptions.OptionName) { return @"Roslyn\Internal\OnOff\Components"; } else if (key.Option.Feature == InternalFeatureOnOffOptions.OptionName) { return @"Roslyn\Internal\OnOff\Features"; } else if (key.Option.Feature == PerformanceFunctionIdOptionsProvider.Name) { return @"Roslyn\Internal\Performance\FunctionId"; } else if (key.Option.Feature == LoggerOptions.FeatureName) { return @"Roslyn\Internal\Performance\Logger"; } else if (key.Option.Feature == InternalDiagnosticsOptions.OptionName) { return @"Roslyn\Internal\Diagnostics"; } else if (key.Option.Feature == InternalSolutionCrawlerOptions.OptionName) { return @"Roslyn\Internal\SolutionCrawler"; } else if (key.Option.Feature == CacheOptions.FeatureName) { return @"Roslyn\Internal\Performance\Cache"; } throw ExceptionUtilities.Unreachable; }
public virtual bool TryPersist(OptionKey optionKey, object value) { // We ignore languageName, since the current use of this class is only for // language-specific options that apply to a single language. The underlying option // service has already ensured the languageName is right, so we'll drop it on the floor. if (this.RegistryKey == null) { throw new InvalidOperationException(); } var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language); if (collectionPathAndPropertyName == null) { return false; } lock (Gate) { using (var subKey = this.RegistryKey.CreateSubKey(collectionPathAndPropertyName.Item1)) { subKey.SetValue(collectionPathAndPropertyName.Item2, (bool)value ? 1 : 0, RegistryValueKind.DWord); } return true; } }
public override OptionSet WithChangedOption(OptionKey optionAndLanguage, object value) { // make sure we first load this in current optionset this.GetOption(optionAndLanguage); return new WorkspaceOptionSet(_service, _values.SetItem(optionAndLanguage, value)); }
public bool TryGetDocumentOption(Document document, OptionKey option, out object value) { var editorConfigPersistence = option.Option.StorageLocations.OfType<EditorConfigStorageLocation>().SingleOrDefault(); if (editorConfigPersistence == null) { value = null; return false; } if (_codingConventionSnapshot.TryGetConventionValue(editorConfigPersistence.KeyName, out value)) { try { value = editorConfigPersistence.ParseValue(value.ToString(), option.Option.Type); return true; } catch (Exception) { // TODO: report this somewhere? return false; } } else { return false; } }
public virtual bool TryFetch(OptionKey optionKey, out object value) { if (this.RegistryKey == null) { throw new InvalidOperationException(); } var collectionPathAndPropertyName = GetCollectionPathAndPropertyNameForOption(optionKey.Option, optionKey.Language); if (collectionPathAndPropertyName == null) { value = null; return false; } lock (Gate) { using (var openSubKey = this.RegistryKey.OpenSubKey(collectionPathAndPropertyName.Item1)) { if (openSubKey == null) { value = null; return false; } value = openSubKey.GetValue(collectionPathAndPropertyName.Item2, defaultValue: (bool)optionKey.Option.DefaultValue ? 1 : 0).Equals(1); return true; } } }
bool IOptionSerializer.TryPersist(OptionKey optionKey, object value) { if (this._registryKey == null) { throw new InvalidOperationException(); } var collectionPath = GetCollectionPathForOption(optionKey); if (collectionPath == null) { return false; } lock (_gate) { using (var subKey = this._registryKey.CreateSubKey(collectionPath)) { // Options that are of type bool have to be serialized as integers if (optionKey.Option.Type == typeof(bool)) { subKey.SetValue(optionKey.Option.Name, (bool)value ? 1 : 0, RegistryValueKind.DWord); return true; } else { subKey.SetValue(optionKey.Option.Name, value); return true; } } } }
private static KeyValueLogMessage Create(OptionKey optionKey, object oldValue, object currentValue) { return KeyValueLogMessage.Create(m => { m[Name] = optionKey.Option.Name; m[Language] = optionKey.Language ?? All; m[Change] = CreateOptionValue(oldValue, currentValue); }); }
public bool TryFetch(OptionKey optionKey, out object value) { if (this._settingManager == null) { Debug.Fail("Manager field is unexpectedly null."); value = null; return false; } // Do we roam this at all? var roamingSerialization = optionKey.Option.StorageLocations.OfType<RoamingProfileStorageLocation>().SingleOrDefault(); if (roamingSerialization == null) { value = null; return false; } var storageKey = roamingSerialization.GetKeyNameForLanguage(optionKey.Language); RecordObservedValueToWatchForChanges(optionKey, storageKey); value = this._settingManager.GetValueOrDefault(storageKey, optionKey.Option.DefaultValue); // VS's ISettingsManager has some quirks around storing enums. Specifically, // it *can* persist and retrieve enums, but only if you properly call // GetValueOrDefault<EnumType>. This is because it actually stores enums just // as ints and depends on the type parameter passed in to convert the integral // value back to an enum value. Unfortunately, we call GetValueOrDefault<object> // and so we get the value back as boxed integer. // // Because of that, manually convert the integer to an enum here so we don't // crash later trying to cast a boxed integer to an enum value. if (optionKey.Option.Type.IsEnum) { if (value != null) { value = Enum.ToObject(optionKey.Option.Type, value); } } else if (optionKey.Option.Type == typeof(CodeStyleOption<bool>)) { // We store these as strings, so deserialize var serializedValue = value as string; if (serializedValue != null) { value = CodeStyleOption<bool>.FromXElement(XElement.Parse(serializedValue)); } else { value = optionKey.Option.DefaultValue; } } return true; }
public void GettingOptionWithChangedOption() { var optionService = TestOptionService.GetService(); var optionSet = optionService.GetOptions(); var option = new Option<bool>("Test Feature", "Test Name", false); var key = new OptionKey(option); Assert.False(optionSet.GetOption(option)); optionSet = optionSet.WithChangedOption(key, true); Assert.True((bool)optionSet.GetOption(key)); }
public override bool TryFetch(OptionKey optionKey, out object value) { switch (optionKey.Option.Feature) { case CacheOptions.FeatureName: case InternalSolutionCrawlerOptions.OptionName: return TryFetch(optionKey, (r, k, o) => r.GetValue(k, defaultValue: o.DefaultValue), out value); } return base.TryFetch(optionKey, out value); }
public override bool TryPersist(OptionKey optionKey, object value) { switch (optionKey.Option.Feature) { case CacheOptions.FeatureName: case InternalSolutionCrawlerOptions.OptionName: return TryPersist(optionKey, value, (r, k, o, v) => r.SetValue(k, v, o.Type == typeof(int) ? RegistryValueKind.DWord : RegistryValueKind.QWord)); } return base.TryPersist(optionKey, value); }
public bool TryFetch(OptionKey optionKey, out object value) { value = string.Empty; if (optionKey != TodoCommentOptions.TokenList) { return false; } value = _taskTokenList; return true; }
private void SetChangedOption(IOptionService optionService, IOption option, string languageName) { OptionKey key = new OptionKey(option, languageName); object currentValue; if (this.TryFetch(key, out currentValue)) { OptionSet optionSet = optionService.GetOptions(); optionSet = optionSet.WithChangedOption(key, currentValue); optionService.SetOptions(optionSet); } }
public override object GetOption(OptionKey optionKey) { lock (_gate) { if (!_values.TryGetValue(optionKey, out var value)) { value = _service != null ? _service.GetOption(optionKey) : optionKey.Option.DefaultValue; _values = _values.Add(optionKey, value); } return value; } }
public int CreateOption(OptionKey option) { using (var db = Context) { var dataOption = _mapperService.Map <Data.OptionKey>(option); dataOption = db.OptionKey.Add(dataOption); dataOption.CreationDate = DateTime.UtcNow; foreach (var val in dataOption.OptionValues) { val.CreationDate = DateTime.UtcNow; db.OptionValue.Add(val); } db.SaveChanges(); return(dataOption.Id); } }
public override bool TryPersist(OptionKey optionKey, object value) { if (optionKey.Option.Feature == CacheOptions.FeatureName) { lock (Gate) { using (var subKey = this.RegistryKey.CreateSubKey(CachePath)) { subKey.SetValue(optionKey.Option.Name, value, optionKey.Option.Type == typeof(int) ? RegistryValueKind.DWord : RegistryValueKind.QWord); return true; } } } return base.TryPersist(optionKey, value); }
public override bool TryPersist(OptionKey optionKey, object value) { if (optionKey.Option.Feature == CacheOptions.FeatureName) { lock (Gate) { using (var subKey = this.RegistryKey.CreateSubKey(CachePath)) { subKey.SetValue(optionKey.Option.Name, value, optionKey.Option.Type == typeof(int) ? RegistryValueKind.DWord : RegistryValueKind.QWord); return(true); } } } return(base.TryPersist(optionKey, value)); }
static string GetSectionHeader(OptionKey optionKey) { if (optionKey.Option.IsPerLanguage) { switch (optionKey.Language) { case LanguageNames.CSharp: return("[*.cs]"); case LanguageNames.VisualBasic: return("[*.vb]"); } } return("[*]"); }
bool IOptionPersister.TryPersist(OptionKey optionKey, object value) { if (this._registryKey == null) { throw new InvalidOperationException(); } if (!TryGetKeyPathAndName(optionKey.Option, out var path, out var key)) { value = null; return(false); } lock (_gate) { using var subKey = this._registryKey.CreateSubKey(path); // Options that are of type bool have to be serialized as integers if (optionKey.Option.Type == typeof(bool)) { subKey.SetValue(key, (bool)value ? 1 : 0, RegistryValueKind.DWord); return(true); } else if (optionKey.Option.Type == typeof(long)) { subKey.SetValue(key, value, RegistryValueKind.QWord); return(true); } else if (optionKey.Option.Type.IsEnum) { // If the enum is larger than an int, store as a QWord if (Marshal.SizeOf(Enum.GetUnderlyingType(optionKey.Option.Type)) > Marshal.SizeOf(typeof(int))) { subKey.SetValue(key, (long)value, RegistryValueKind.QWord); } else { subKey.SetValue(key, (int)value, RegistryValueKind.DWord); } return(true); } else { subKey.SetValue(key, value); return(true); } } }
void ConfigureWorkspaceForDocument(Document document, FileConfiguration config) { // Microsoft.CodeAnalysis.Options.IOptionService var optionService = workspace .AsDynamicReflection() ._workspaceOptionService; // Get the registered options in the roslyn workspace IEnumerable <IOption> registeredOptions = optionService.GetRegisteredOptions(); foreach (var option in registeredOptions.Where(x => x.StorageLocations != null)) { // Get the EditorConfig storage of the option OptionStorageLocation editorConfigStorageLocation = option .StorageLocations .FirstOrDefault(x => x.GetType().Name == "EditorConfigStorageLocation`1"); // If it's null, it means that the option in the workspace does not have a corresponding storage in the .editorconfig file. if (editorConfigStorageLocation != null) { string editorConfigKey = editorConfigStorageLocation.AsDynamicReflection().KeyName; // Get the value in the .editorconfig associated with the editorConfig storage key if (config.Properties.TryGetValue(editorConfigKey, out var editorConfigValue)) { // Map the value in the .editorconfig file to the Option value in the roslyn workspace // by invoking Microsoft.CodeAnalysis.Options.EditorConfigStorageLocation<T>.TryOption(...) object optionValue = default(object); if (editorConfigStorageLocation.AsDynamicReflection().TryGetOption( option, new ReadOnlyDictionary <string, object>(new Dictionary <string, object> { { editorConfigKey, editorConfigValue } }), option.Type, OutValue.Create <object>(x => optionValue = x))) { var optionKey = new OptionKey( option, option.IsPerLanguage ? document.Project.Language : null); workspace.Options = workspace.Options.WithChangedOption(optionKey, optionValue); } } } } }
private void RefreshLanguageSettings(LANGPREFERENCES3[] langPrefs) { this.AssertIsForeground(); string languageName; if (_languageMap.TryGetKey(langPrefs[0].guidLang, out languageName)) { foreach (var option in _supportedOptions) { var keyWithLanguage = new OptionKey(option, languageName); object newValue = GetValueForOption(option, langPrefs[0]); _optionService.RefreshOption(keyWithLanguage, newValue); } } }
public bool TryPersist(OptionKey optionKey, object value) { // Property bindings if (preferences.TryGetUpdater(optionKey, out string storageKey, out var updater)) { MonitorChanges(storageKey, optionKey); try { var serializedValue = Serialize(value, optionKey.Option.Type); updater(serializedValue); return(true); } catch (Exception ex) { LoggingService.LogError($"Failed to serialize key: {storageKey} type: {optionKey.Option.Type}", ex); } } return(false); }
public void OrderingOfEditorConfigMaintained() { using var tempRoot = new TempRoot(); var tempDirectory = tempRoot.CreateDirectory(); // Write out an .editorconfig. We'll write out 100 random GUIDs var expectedKeysInOrder = new List <string>(); using (var writer = new StreamWriter(tempDirectory.CreateFile(".editorconfig").Path)) { writer.WriteLine("root = true"); writer.WriteLine("[*.cs]"); for (int i = 0; i < 100; i++) { var key = Guid.NewGuid().ToString(); expectedKeysInOrder.Add(key); writer.WriteLine($"{key} = value"); } } // Create a workspace with a file in that path var codingConventionsCatalog = ExportProviderCache.GetOrCreateAssemblyCatalog(typeof(ICodingConventionsManager).Assembly).WithPart(typeof(MockFileWatcher)); var exportProvider = ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(codingConventionsCatalog)).CreateExportProvider(); using var workspace = TestWorkspace.CreateWorkspace( new XElement("Workspace", new XElement("Project", new XAttribute("Language", "C#"), new XElement("Document", new XAttribute("FilePath", tempDirectory.CreateFile("Test.cs").Path)))), exportProvider: exportProvider); var document = workspace.CurrentSolution.Projects.Single().Documents.Single(); var providerFactory = workspace.ExportProvider.GetExportedValues <IDocumentOptionsProviderFactory>().OfType <LegacyEditorConfigDocumentOptionsProviderFactory>().Single(); var provider = providerFactory.TryCreate(workspace); var option = new Option <List <string> >(nameof(LegacyEditorConfigDocumentOptionsProviderTests), nameof(OrderingOfEditorConfigMaintained), null, new[] { new KeysReturningStorageLocation() }); var optionKey = new OptionKey(option); // Fetch the underlying option order with a "option" that returns the keys provider.GetOptionsForDocumentAsync(document, CancellationToken.None).Result.TryGetDocumentOption(optionKey, workspace.Options, out object actualKeysInOrderObject); var actualKeysInOrder = Assert.IsAssignableFrom <IEnumerable <string> >(actualKeysInOrderObject); Assert.Equal(expectedKeysInOrder, actualKeysInOrder); }
public bool TryPersist(OptionKey optionKey, object value) { if (_settingManager == null) { Debug.Fail("Manager field is unexpectedly null."); return(false); } // Do we roam this at all? var roamingSerialization = optionKey.Option.StorageLocations.OfType <RoamingProfileStorageLocation>().SingleOrDefault(); if (roamingSerialization == null) { value = null; return(false); } var storageKey = roamingSerialization.GetKeyNameForLanguage(optionKey.Language); RecordObservedValueToWatchForChanges(optionKey, storageKey); if (optionKey.Option.Type == typeof(CodeStyleOption <bool>)) { // We store these as strings, so serialize var valueToSerialize = value as CodeStyleOption <bool>; if (value != null) { value = valueToSerialize.ToXElement().ToString(); } } else if (optionKey.Option.Type == typeof(NamingStylePreferences)) { // We store these as strings, so serialize var valueToSerialize = value as NamingStylePreferences; if (value != null) { value = valueToSerialize.CreateXElement().ToString(); } } _settingManager.SetValueAsync(storageKey, value, isMachineLocal: false); return(true); }
static void PrintOptionKey(OptionKey optionKey) { Console.WriteLine($"Name '{optionKey.Option.Name}' Language '{optionKey.Language}' LanguageSpecific'{optionKey.Option.IsPerLanguage}'"); var locations = optionKey.Option.StorageLocations; if (locations.IsDefault) { return; } foreach (var loc in locations) { switch (loc) { case RoamingProfileStorageLocation roaming: Console.WriteLine($" roaming: {roaming.GetKeyNameForLanguage (optionKey.Language)}"); break; case LocalUserProfileStorageLocation local: Console.WriteLine($" local: {local.KeyName}"); break; case EditorConfigStorageLocation <int> edconf: Console.WriteLine($" editorconfig: {edconf.KeyName}"); break; case EditorConfigStorageLocation <string> edconf: Console.WriteLine($" editorconfig: {edconf.KeyName}"); break; case EditorConfigStorageLocation <bool> edconf: Console.WriteLine($" editorconfig: {edconf.KeyName}"); break; case EditorConfigStorageLocation <Microsoft.CodeAnalysis.CodeStyle.CodeStyleOption <bool> > edconf: Console.WriteLine($" editorconfig: {edconf.KeyName}"); break; default: Console.WriteLine($" unknown: {loc.GetType ()}"); break; } } }
public bool TryGetDocumentOption(OptionKey option, [NotNullWhen(true)] out object?value) { if (option == _useTabsOptionKey) { value = _editorSettings.IndentWithTabs; return(true); } else if (option == _tabSizeOptionKey || option == _indentationSizeOptionKey) { value = _editorSettings.IndentSize; return(true); } else { value = null; return(false); } }
public virtual bool TryPersist(OptionKey optionKey, object value) { if (this.Manager == null) { Debug.Fail("Manager field is unexpectedly null."); return(false); } if (!SupportsOption(optionKey.Option, optionKey.Language)) { return(false); } var storageKey = GetStorageKeyForOption(optionKey.Option); this.Manager.SetValueAsync(storageKey, value, isMachineLocal: false); return(true); }
public static void Load() { ModConfig config = new ModConfig(); int v = (int)KeyCode.K; config.TryGetConfig <int>("musicKeycode", ref v); musicKeycode = (KeyCode)v; OptionKey musicKey = new OptionKey("Music Controller toggle", "TerraWave", musicKeycode); musicKey.onValueSaved.AddListener(() => { musicKeycode = musicKey.SavedValue; config["musicKeycode"] = (int)musicKeycode; config.WriteConfigJsonFile(); }); var harmony = HarmonyInstance.Create("Exund.ModOptionsTab"); harmony.PatchAll(Assembly.GetExecutingAssembly()); var materials = Resources.FindObjectsOfTypeAll <Material>(); var Skydome_Planets = materials.First(m => m.name == "Skydome_Planets"); var Moon = materials.First(m => m.name == "Moon"); assets_path = Path.Combine(Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName, "Assets"); var Skydome_Planets_Albedo = new Texture2D(0, 0); Skydome_Planets_Albedo.LoadImage(File.ReadAllBytes(Path.Combine(assets_path, "Skydome_Planets_Albedo.png"))); Skydome_Planets.mainTexture = Skydome_Planets_Albedo; var moon_texture = new Texture2D(0, 0); moon_texture.LoadImage(File.ReadAllBytes(Path.Combine(assets_path, "moon_texture.png"))); Moon.mainTexture = moon_texture; Moon.SetTexture("_MainTex", moon_texture); var handler = new GameObject(); handler.AddComponent <AudioSource>(); handler.AddComponent <MusicLoader>(); GameObject.DontDestroyOnLoad(handler); }
internal bool TryGet(OptionKey key, out string propertyKey, out object value) { // Check for roaming/profile properties propertyKey = key.GetPropertyName(); if (propertyKey != null) { var defaultValue = key.Option.DefaultValue; if (TryGetSerializationMethods <object> (key.Option.Type, out var serializer, out var deserializer)) { defaultValue = serializer(defaultValue); } value = PropertyService.Get(propertyKey, defaultValue); return(true); } value = default(object); return(false); }
public void UpdateOption(OptionKey option) { using (var db = Context) { var dataOption = _mapperService.Map <Data.OptionKey>(option); dataOption = db.OptionKey.Attach(dataOption); db.Entry(dataOption).State = EntityState.Modified; foreach (var val in dataOption.OptionValues) { val.OptionKeyId = dataOption.Id; } //D var optValues = db.OptionValue.Where(x => x.OptionKeyId == option.Id); foreach (var optValue in optValues) { if (!option.OptionValues.Any(x => x.Id == optValue.Id)) { db.OptionValue.Remove(optValue); } } foreach (var optValue in option.OptionValues) { if (optValue.Id == 0) { //C var dataOptValue = _mapperService.Map <Data.OptionValue>(optValue); dataOptValue.CreationDate = DateTime.UtcNow; db.OptionValue.Add(dataOptValue); } else { //U var dataOptValue = dataOption.OptionValues.Single(x => x.Id == optValue.Id); db.Entry(dataOptValue).State = EntityState.Modified; } } db.SaveChanges(); } }
public void RefreshOption(OptionKey optionKey, object newValue) { lock (_gate) { if (_currentValues.TryGetValue(optionKey, out var oldValue)) { if (object.Equals(oldValue, newValue)) { // Value is still the same, no reason to raise events return; } } _currentValues = _currentValues.SetItem(optionKey, newValue); } RaiseEvents(new List <OptionChangedEventArgs> { new OptionChangedEventArgs(optionKey, newValue) }); }
public void TestRoslynPropertyWithMultipleKeys() { var(preferences, persister) = Setup(); var option = new PerLanguageOption <bool> ("test", "name", false, new RoamingProfileStorageLocation("feature.%LANGUAGE%.test"), new RoamingProfileStorageLocation("feature.test")); var optionKey = new OptionKey(option, LanguageNames.CSharp); var propertyNames = optionKey.GetPropertyNames().ToArray(); Assert.AreEqual(2, propertyNames.Length); Assert.AreEqual("feature.CSharp.test", propertyNames [0]); Assert.AreEqual("feature.test", propertyNames [1]); PropertyService.Set(propertyNames [1], true); var success = persister.TryFetch(optionKey, out object value); Assert.AreEqual(true, success); Assert.AreEqual(true, value); }
private protected override object?GetOptionCore(OptionKey optionKey) { // If we already know the document specific value, we're done if (_values.TryGetValue(optionKey, out var value)) { return(value); } foreach (var documentOptionSource in _documentOptions) { if (documentOptionSource.TryGetDocumentOption(optionKey, out value)) { // Cache and return return(ImmutableInterlocked.GetOrAdd(ref _values, optionKey, value)); } } // We don't have a document specific value, so forward return(_underlyingOptions.GetOption(optionKey)); }
public static IEnumerable <string> GetPropertyNames(this OptionKey optionKey) { // Prevent NRE being thrown on iteration. if (optionKey.Option.StorageLocations.IsDefaultOrEmpty) { yield break; } foreach (var storageLocation in optionKey.Option.StorageLocations) { if (storageLocation is RoamingProfileStorageLocation roamingLocation) { yield return(roamingLocation.GetKeyNameForLanguage(optionKey.Language)); } if (storageLocation is LocalUserProfileStorageLocation userLocation) { yield return(userLocation.KeyName); } } }
public bool TryGetDocumentOption(OptionKey option, out object?value) { var editorConfigPersistence = option.Option.StorageLocations.OfType <IEditorConfigStorageLocation>().SingleOrDefault(); if (editorConfigPersistence == null) { value = null; return(false); } try { return(editorConfigPersistence.TryGetOption(_options.AsNullable(), option.Option.Type, out value)); } catch (Exception e) when(FatalError.ReportWithoutCrash(e)) { value = null; return(false); } }
public bool TryGetDocumentOption(OptionKey option, out object?value) { var editorConfigPersistence = option.Option.StorageLocations.OfType <IEditorConfigStorageLocation>().SingleOrDefault(); if (editorConfigPersistence == null) { value = null; return(false); } try { return(editorConfigPersistence.TryGetOption(_options, option.Option.Type, out value)); } catch (Exception ex) { _errorLogger?.LogException(this, ex); value = null; return(false); } }
public void GettingOptionWithoutChangedOption() { var optionService = TestOptionService.GetService(); var optionSet = optionService.GetOptions(); var optionFalse = new Option <bool>("Test Feature", "Test Name", false); Assert.False(optionSet.GetOption(optionFalse)); var optionTrue = new Option <bool>("Test Feature", "Test Name", true); Assert.True(optionSet.GetOption(optionTrue)); var falseKey = new OptionKey(optionFalse); Assert.False((bool)optionSet.GetOption(falseKey)); var trueKey = new OptionKey(optionTrue); Assert.True((bool)optionSet.GetOption(trueKey)); }
public async Task TestFullSolutionAnalysis(string language, bool enabledByDefault) { var pref = IdeApp.Preferences.Roslyn; var perLanguagePref = pref.For(language); using (var mdw = await IdeApp.TypeSystemService.CreateEmptyWorkspace()) { var key = new OptionKey(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, language); var old = mdw.Options.GetOption(key); try { // Set the closed file diagnostics to default. mdw.Options = mdw.Options.WithChangedOption(key, null); Assert.IsTrue(pref.FullSolutionAnalysisRuntimeEnabled); Assert.IsTrue(mdw.Options.GetOption(RuntimeOptions.FullSolutionAnalysis)); Assert.AreEqual(enabledByDefault, perLanguagePref.SolutionCrawlerClosedFileDiagnostic.Value); // Set closed file diagnostics to false, this should not impact runtime options mdw.Options = mdw.Options.WithChangedOption(key, false); Assert.IsTrue(pref.FullSolutionAnalysisRuntimeEnabled); Assert.IsTrue(mdw.Options.GetOption(RuntimeOptions.FullSolutionAnalysis)); Assert.IsFalse(perLanguagePref.SolutionCrawlerClosedFileDiagnostic.Value); // Set closed file diagnostics to true, this should turn on everything // Ensure FSA is off at this point. mdw.Options = mdw.Options.WithChangedOption(RuntimeOptions.FullSolutionAnalysis, false); pref.FullSolutionAnalysisRuntimeEnabled = false; mdw.Options = mdw.Options.WithChangedOption(key, true); Assert.IsTrue(pref.FullSolutionAnalysisRuntimeEnabled); Assert.IsTrue(mdw.Options.GetOption(RuntimeOptions.FullSolutionAnalysis)); Assert.IsTrue(perLanguagePref.SolutionCrawlerClosedFileDiagnostic.Value); } finally { mdw.Options = mdw.Options.WithChangedOption(key, old); pref.FullSolutionAnalysisRuntimeEnabled = true; mdw.Options = mdw.Options.WithChangedOption(RuntimeOptions.FullSolutionAnalysis, true); } } }
public bool TryFetch(OptionKey optionKey, out object?value) { // This option is refreshed via the constructor to avoid UI dependencies when retrieving option values. If // we happen to reach this point before the value is available, try to obtain it without blocking, and // otherwise fall back to the default. if (optionKey.Option == SolutionCrawlerOptions.SolutionBackgroundAnalysisScopeOption) { if (_lazyRoslynPackage is not null) { value = _lazyRoslynPackage.AnalysisScope; return(true); } else { value = SolutionCrawlerOptions.SolutionBackgroundAnalysisScopeOption.DefaultValue; return(true); } } value = null; return(false); }
public override bool TryFetch(OptionKey optionKey, out object value) { if (optionKey.Option.Feature == CacheOptions.FeatureName) { lock (Gate) { using (var openSubKey = this.RegistryKey.OpenSubKey(CachePath)) { if (openSubKey == null) { value = null; return false; } value = openSubKey.GetValue(optionKey.Option.Name, defaultValue: optionKey.Option.DefaultValue); return true; } } } return base.TryFetch(optionKey, out value); }
public virtual bool TryFetch(OptionKey optionKey, out object value) { value = null; if (this.Manager == null) { Debug.Fail("Manager field is unexpectedly null."); return(false); } if (!SupportsOption(optionKey.Option, optionKey.Language)) { value = null; return(false); } var storageKey = GetStorageKeyForOption(optionKey.Option); value = this.Manager.GetValueOrDefault(storageKey, optionKey.DefaultValue); return(true); }
/// <summary> /// Asks the server to retrieve an integer config key, producing a task that waits until either /// the config cache receives it or the given timeout period elapses. /// </summary> /// <param name="key">The key to retrieve.</param> /// <param name="timeout">A time-span that, will be used as the timeout for this poll.</param> /// <param name="fallback">A fallback value to use if the timeout elapses.</param> /// <param name="index">If given, the specific index to retrieve.</param> /// <returns>A task that completes with the retrieved integer value.</returns> public int PollInt(OptionKey key, TimeSpan timeout, int fallback = -1, int index = ConfigCache.NoIndex) { var mainObservable = Observable.FromEventPattern <ConfigCache.IntChangeEventArgs>( ev => { _cache.IntChanged += ev; // This is a strange place to put this, but necessary; // the BapsNet conversation that results in receiving the config setting has to // take place within the time window that 'ev' is registered. var cmd = new NonIndexedConfigCommand(ConfigOp.GetConfigSetting, false); Send(new MessageBuilder(cmd).Add((uint)key)); }, ev => _cache.IntChanged -= ev ).FirstAsync( ev => ev.EventArgs.Key == key && ev.EventArgs.Index == index ).Select( ev => ev.EventArgs.Value ); var fallbackObservable = Observable.Return(fallback).Delay(timeout); return(mainObservable.Amb(fallbackObservable).Wait()); }
public override bool TryFetch(OptionKey optionKey, out object value) { if (optionKey.Option.Feature == CacheOptions.FeatureName) { lock (Gate) { using (var openSubKey = this.RegistryKey.OpenSubKey(CachePath)) { if (openSubKey == null) { value = null; return(false); } value = openSubKey.GetValue(optionKey.Option.Name, defaultValue: optionKey.Option.DefaultValue); return(true); } } } return(base.TryFetch(optionKey, out value)); }
public void SetOptionAndUpdatePreview <T>(T value, IOption option, string preview) { var key = new OptionKey(option, option.IsPerLanguage ? Language : null); if (option.DefaultValue is ICodeStyleOption codeStyleOption) { // The value provided is either an ICodeStyleOption OR the underlying ICodeStyleOption.Value if (value is ICodeStyleOption newCodeStyleOption) { OptionStore.SetOption(key, codeStyleOption.WithValue(newCodeStyleOption.Value).WithNotification(newCodeStyleOption.Notification)); } else { OptionStore.SetOption(key, codeStyleOption.WithValue(value)); } } else { OptionStore.SetOption(key, value); } UpdateDocument(preview); }
public bool TryGetDocumentOption(Document document, OptionKey option, out object value) { var editorConfigPersistence = option.Option.StorageLocations.OfType <EditorConfigStorageLocation>().SingleOrDefault(); if (editorConfigPersistence == null) { value = null; return(false); } var allRawConventions = _codingConventionSnapshot.AllRawConventions; try { return(editorConfigPersistence.TryParseReadonlyDictionary(allRawConventions, option.Option.Type, out value)); } catch (Exception ex) { _errorLogger?.LogException(this, ex); value = null; return(false); } }
private bool TryGetOptionForBuffer(ITextBuffer textBuffer, OptionKey option, out object?value) { if (option.Option == FormattingOptions.UseTabs) { value = !_indentationManagerService.UseSpacesForWhitespace(textBuffer, explicitFormat: false); return(true); } else if (option.Option == FormattingOptions.TabSize) { value = _indentationManagerService.GetTabSize(textBuffer, explicitFormat: false); return(true); } else if (option.Option == FormattingOptions.IndentationSize) { value = _indentationManagerService.GetIndentSize(textBuffer, explicitFormat: false); return(true); } else { value = null; return(false); } }
bool IOptionPersister.TryFetch(OptionKey optionKey, out object value) { string path; string key; if (!TryGetKeyPathAndName(optionKey.Option, out path, out key)) { value = null; return false; } lock (_gate) { using (var subKey = this._registryKey.OpenSubKey(path)) { if (subKey == null) { value = null; return false; } // Options that are of type bool have to be serialized as integers if (optionKey.Option.Type == typeof(bool)) { value = subKey.GetValue(key, defaultValue: (bool)optionKey.Option.DefaultValue ? 1 : 0).Equals(1); return true; } else { // Otherwise we can just store normally value = subKey.GetValue(key, defaultValue: optionKey.Option.DefaultValue); return true; } } } }
internal override bool ShouldPersistOption(OptionKey key) { return key.Option.Feature == CSharpFormattingOptions.NewLineFormattingFeatureName; }
internal IDictionary<OptionKey, object> OptionSet(OptionKey option, object value) { var options = new Dictionary<OptionKey, object>(); options.Add(option, value); return options; }
public bool TryPersist(OptionKey optionKey, object value) { if (this._settingManager == null) { Debug.Fail("Manager field is unexpectedly null."); return false; } // Do we roam this at all? var roamingSerialization = optionKey.Option.StorageLocations.OfType<RoamingProfileStorageLocation>().SingleOrDefault(); if (roamingSerialization == null) { value = null; return false; } var storageKey = roamingSerialization.GetKeyNameForLanguage(optionKey.Language); RecordObservedValueToWatchForChanges(optionKey, storageKey); if (optionKey.Option.Type == typeof(CodeStyleOption<bool>)) { // We store these as strings, so serialize var valueToSerialize = value as CodeStyleOption<bool>; if (value != null) { value = valueToSerialize.ToXElement().ToString(); } } this._settingManager.SetValueAsync(storageKey, value, isMachineLocal: false); return true; }
protected IDictionary<OptionKey, object> OptionsSet(params Tuple<IOption, bool, NotificationOption>[] optionsToSet) { var options = new Dictionary<OptionKey, object>(); foreach (var triple in optionsToSet) { var option = triple.Item1; var value = triple.Item2; var notification = triple.Item3; var optionKey = new OptionKey(option, option.IsPerLanguage ? GetLanguage() : null); options.Add(optionKey, new CodeStyleOption<bool>(value, notification)); } return options; }
public virtual bool TryFetch(OptionKey optionKey, out object value) { value = null; if (this.Manager == null) { Debug.Fail("Manager field is unexpectedly null."); return false; } if (!SupportsOption(optionKey.Option, optionKey.Language)) { value = null; return false; } var storageKey = GetStorageKeyForOption(optionKey.Option); value = this.Manager.GetValueOrDefault(storageKey, optionKey.Option.DefaultValue); return true; }
public virtual bool TryPersist(OptionKey optionKey, object value) { if (this.Manager == null) { Debug.Fail("Manager field is unexpectedly null."); return false; } if (!SupportsOption(optionKey.Option, optionKey.Language)) { return false; } var storageKey = GetStorageKeyForOption(optionKey.Option); this.Manager.SetValueAsync(storageKey, value, isMachineLocal: false); return true; }
private void RefreshLanguageSettings(LANGPREFERENCES3[] langPrefs) { this.AssertIsForeground(); if (_languageMap.TryGetKey(Tuple.Create(langPrefs[0].guidLang), out var languageName)) { foreach (var option in _supportedOptions) { var keyWithLanguage = new OptionKey(option, languageName); object newValue = GetValueForOption(option, langPrefs[0]); _optionService.RefreshOption(keyWithLanguage, newValue); } } }
private IDictionary<OptionKey, object> Options(OptionKey option, object value) { var options = new Dictionary<OptionKey, object>(); options.Add(option, value); return options; }
public bool TryPersist(OptionKey optionKey, object value) { if (!_supportedOptions.Contains(optionKey.Option)) { value = null; return false; } if (!_languageMap.TryGetValue(optionKey.Language, out var languageServiceGuid)) { value = null; return false; } var languagePreferences = new LANGPREFERENCES3[1]; languagePreferences[0].guidLang = languageServiceGuid.Item1; Marshal.ThrowExceptionForHR(_textManager.GetUserPreferences4(null, languagePreferences, null)); SetValueForOption(optionKey.Option, ref languagePreferences[0], value); SetUserPreferencesMaybeAsync(languagePreferences); // Even if we didn't call back, say we completed the persist return true; }
public bool TryFetch(OptionKey optionKey, out object value) { // This particular serializer is a bit strange, since we have to initially read things out on the UI thread. // Therefore, we refresh the values in the constructor, meaning that this should never get called for our values. Contract.ThrowIfTrue(_supportedOptions.Contains(optionKey.Option)); value = null; return false; }