/// <inheritdoc /> public ISettingsNode Merge(ISettingsNode other, SettingsMergeOptions options = null) { if (other == null) { return(this); } if (!(other is ArrayNode)) { return(other); } options = options ?? SettingsMergeOptions.Default; switch (options.ArrayMergeStyle) { case ArrayMergeStyle.Replace: return(other); case ArrayMergeStyle.Concat: return(new ArrayNode(other.Name, children.Concat(other.Children).ToArray())); case ArrayMergeStyle.Union: return(new ArrayNode(other.Name, children.Union(other.Children).ToArray())); default: return(null); } }
public SettingsUpdaterResult(bool changed, long version, SettingsVersionType versionType, ISettingsNode settings) { Changed = changed; Version = version; VersionType = versionType; Settings = settings; }
public ISettingsNode Convert(ISettingsNode node) { switch (node) { case ValueNode valueNode: return(valueNode); case ArrayNode arrayNode: return(new ArrayNode(arrayNode.Name, arrayNode.Children.Select(Convert).ToArray())); case ObjectNode objectNode: if (IsRedundantObjectNode(objectNode)) { var singleChild = objectNode.Children.Single(); //Make no difference between empty and nonexistent file. if (string.IsNullOrEmpty(singleChild.Value) && !singleChild.Children.Any()) { return(new ObjectNode(objectNode.Name)); } return(objectNode.Children.Single().WithName(objectNode.Name)); } return(new ObjectNode(objectNode.Name, objectNode.Children.Select(Convert))); default: return(node); } }
public INode GetNode(string name) { ISettingsNode child = this.node.GetSubNode(name); INode result = new SettingsNode(child); return(result); }
private static ISettingsNode Nest(ISettingsNode node, params string[] scopes) { var baseSource = new ConstantSource(node); var nestingSource = new NestingSource(baseSource, scopes); return(nestingSource.Observe().WaitFirstValue(TimeSpan.FromSeconds(5)).settings); }
private void Load(ISettingsNode settingsNode) { ISettingsNode peerGroupsNode = settingsNode.GetSubNode(nameof(this.PeerGroups), false); if (peerGroupsNode != null) { foreach (string subNodeName in peerGroupsNode.GetSubNodeNames()) { ISettingsNode peerGroupNode = peerGroupsNode.GetSubNode(subNodeName, false); PeerGroup peerGroup = PeerGroup.TryLoad(peerGroupNode); if (peerGroup != null) { this.PeerGroups.Add(peerGroup); } } } Dictionary <Guid, PeerGroup> idToGroupMap = this.PeerGroups.ToDictionary(group => group.Id); ISettingsNode locationsNode = settingsNode.GetSubNode(nameof(this.Locations), false); if (locationsNode != null) { foreach (string subNodeName in locationsNode.GetSubNodeNames()) { ISettingsNode locationNode = locationsNode.GetSubNode(subNodeName, false); Location location = Location.TryLoad(locationNode, idToGroupMap); if (location != null) { this.Locations.Add(location); } } } }
public TSettings Bind <TSettings>(ISettingsNode rawSettings) { var value = binder.Bind <TSettings>(rawSettings); Validate(value); return(value); }
public ISettingsNode Convert(ISettingsNode node) { string[] nameParts; switch (node) { case ValueNode valueNode: if (!TrySplitName(valueNode, out nameParts)) { return(valueNode); } return(TreeFactory.CreateTreeByMultiLevelKey(nameParts[0], nameParts.Skip(1).ToArray(), valueNode.Value)); case ArrayNode arrayNode: var children = MergeRedundantObjectNodes(arrayNode.Children.Select(Convert)); if (!IsArrayNodeOfValueNodes(arrayNode) || !TrySplitName(arrayNode, out nameParts)) { return(new ArrayNode(arrayNode.Name, children)); } return(TreeFactory.CreateTreeByMultiLevelKey(nameParts[0], nameParts.Skip(1), new ArrayNode(nameParts.Last(), children))); case ObjectNode objectNode: return(new ObjectNode(objectNode.Name, MergeRedundantObjectNodes(objectNode.Children.Select(Convert)))); default: return(node); } }
public static Dictionary <ClusterConfigPath, List <string> > Flatten([CanBeNull] this ISettingsNode node) { var result = new Dictionary <ClusterConfigPath, List <string> >(); VisitNodeInternal(node, new List <string>(), result); return(result); }
public static void Save(ISettingsNode node) { node.SetValue(nameof(InsertedColor), InsertedColor.ToArgb()); node.SetValue(nameof(DeletedColor), DeletedColor.ToArgb()); node.SetValue(nameof(ChangedColor), ChangedColor.ToArgb()); node.SetValue(nameof(SpacesPerTab), SpacesPerTab); node.SetValue(nameof(HatchDeadSpace), HatchDeadSpace); }
public static string Render([CanBeNull] ISettingsNode node) { var builder = new StringBuilder(); RenderInternal(node, builder, 0); return(builder.ToString()); }
internal void Save(ISettingsNode settingsNode) { Debug.Assert(this.Id.ToString() == settingsNode.NodeName, "The Id should be the node name."); settingsNode.SetValue("PeerGroupId", this.PeerGroup.Id); settingsNode.SetValue(nameof(this.Name), this.Name); settingsNode.SetValue(nameof(this.Address), this.Address.ToString()); }
public void SetUp() { binder = Substitute.For <ISettingsBinder>(); cachingBinder = new CachingBinder(binder); node = new ValueNode("value"); settings = new object(); }
public void Save(ISettingsNode settingsNode) { settingsNode.SetValue(nameof(this.ShowWindow), this.ShowWindow); settingsNode.SetValue(nameof(this.ShowNotification), this.ShowNotification); settingsNode.SetValue(nameof(this.ColorInactiveTaskbarItem), this.ColorInactiveTaskbarItem); settingsNode.SetValue(nameof(this.PlaySound), this.PlaySound); settingsNode.SetValue(nameof(this.SoundFileName), this.SoundFileName); }
private void Saver_SaveSettings(object sender, SettingsEventArgs e) { if (this.CurrentGizmo != null) { string path = this.GetGizmoSettingsNodePath(false); ISettingsNode gizmoNode = e.SettingsNode.GetSubNode(path, true); this.CurrentGizmo.SaveSettings(gizmoNode); } }
internal void Save(ISettingsNode settingsNode) { Debug.Assert(this.Id.ToString() == settingsNode.NodeName, "The Id should be the node name."); settingsNode.SetValue(nameof(this.Name), this.Name); settingsNode.SetValue(nameof(this.Fail), this.Fail); settingsNode.SetValue(nameof(this.Poll), this.Poll); settingsNode.SetValue(nameof(this.Wait), this.Wait); }
private static ISettingsNode Nest([CanBeNull] ISettingsNode node, [NotNull] string[] scopes) { if (node == null || scopes.Length == 0) { return(node); } return(TreeFactory.CreateTreeByMultiLevelKey(null, scopes, PatchName(node, scopes.Last()))); }
protected override void OnSaveSettings(ISettingsNode settings) { base.OnSaveSettings(settings); settings.SetValue("Show Zeros", this.ShowZeros); settings.SetValue("Show Tenths", this.ShowTenths); settings.SetValue("Top Count", this.TopCount); settings.SetValue("Refresh Seconds", this.timer.Interval.TotalSeconds); }
public static void Save(ISettingsNode node) { node.SetValue("MaxWorkMinutes", (int)MaxWorkTime.TotalMinutes); node.SetValue("MinBreakSeconds", (int)MinBreakTime.TotalSeconds); node.SetValue(nameof(ShowProgress), ShowProgress); node.SetValue(nameof(PlaySound), PlaySound); node.SetValue(nameof(StartScreenSaver), StartScreenSaver); node.SetValue("ScreenSaverDelayMinutes", (int)ScreenSaverDelay.TotalMinutes); node.SetValue("SnoozeMinutes", (int)SnoozeTime.TotalMinutes); }
internal void SaveNonWindowSettings() { using (ISettingsStore store = ApplicationInfo.CreateUserSettingsStore()) { ISettingsNode settings = store.RootNode; this.profile?.Save(settings.GetSubNode(nameof(Profile), true)); this.appOptions?.Save(settings.GetSubNode(nameof(AppOptions), true)); store.Save(); } }
private void LogApplicationConfiguration(ISettingsNode configuration) { try { log.Info($"Application configuration: {Environment.NewLine}{{ApplicationConfiguration}}.", configuration); } catch { log.Warn("Application configuration is unknown."); } }
public ClusterConfigClientState( [CanBeNull] ISettingsNode localTree, [CanBeNull] RemoteTree remoteTree, [NotNull] RecyclingBoundedCache <ClusterConfigPath, ISettingsNode> cache, long version) { LocalTree = localTree; RemoteTree = remoteTree; Cache = cache; Version = version; }
public CommonOptions(ISettingsNode settingsNode) { if (settingsNode != null) { this.logFileNameFormat = settingsNode.GetValue(nameof(this.LogFileNameFormat), this.LogFileNameFormat); this.logFolder = settingsNode.GetValue(nameof(this.LogFolder), string.Empty); } this.ValidateLogFileNameFormat(); this.ValidateLogFolder(); }
public static IDictionary <string, string> Flatten(this ISettingsNode settingsNode) { var context = new List <string>(); IDictionary <string, string> result = new SortedDictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (settingsNode != null) { VisitNodeInternal(settingsNode, context, result); } return(result); }
public static void Apply([NotNull] ISettingsNode content, [NotNull] ClusterConfigClientSettings settings) { if (TryGet <bool>(content, nameof(ClusterConfigClientSettings.EnableLocalSettings), "enableLocalSettings", bool.TryParse, out var enableLocalSettings)) { settings.EnableLocalSettings = enableLocalSettings; } if (TryGet <bool>(content, nameof(ClusterConfigClientSettings.EnableClusterSettings), "enableClusterSettings", bool.TryParse, out var enableClusterSettings)) { settings.EnableClusterSettings = enableClusterSettings; } if (TryGet <TimeSpan>(content, nameof(ClusterConfigClientSettings.UpdatePeriod), "refreshPeriod", TimeSpan.TryParse, out var updatePeriod)) { settings.UpdatePeriod = updatePeriod; } if (TryGet <TimeSpan>(content, nameof(ClusterConfigClientSettings.RequestTimeout), "requestTimeout", TimeSpan.TryParse, out var requestTimeout)) { settings.RequestTimeout = requestTimeout; } if (TryGet(content, nameof(ClusterConfigClientSettings.Zone), "clusterSettingsZoneName", out var zone)) { settings.Zone = zone; } if (TryGet(content, nameof(ClusterConfigClientSettings.LocalFolder), "localSettingsDirectory", out var localFolder)) { settings.LocalFolder = localFolder; } if (TryGet(content, "clusterConfigHost", out var dnsEndpoint)) { var parts = dnsEndpoint.Split(':'); if (parts.Length == 2 && !string.IsNullOrEmpty(parts[0]) && int.TryParse(parts[1], out var port)) { settings.Cluster = new DnsClusterProvider(parts[0], port); } } else { var foundDns = TryGet(content, "ServerDNS", out var dns); var foundPort = TryGet(content, "ServerPort", int.TryParse, out int port); if (foundDns || foundPort) { settings.Cluster = new DnsClusterProvider( dns ?? ClusterConfigClientDefaults.Dns, port == default ? ClusterConfigClientDefaults.Port : port); } } }
public void Save(ISettingsNode settingsNode) { settingsNode.SetValue(nameof(this.RunAtLogin), this.RunAtLogin); settingsNode.SetValue(nameof(this.AutoStartMinimized), this.AutoStartMinimized); settingsNode.SetValue(nameof(this.MinimizeToTray), this.MinimizeToTray); settingsNode.SetValue(nameof(this.AlwaysOnTop), this.AlwaysOnTop); settingsNode.SetValue(nameof(this.ConfirmClose), this.ConfirmClose); this.FailureOptions.Save(settingsNode.GetSubNode(nameof(this.FailureOptions), true)); this.ReconnectOptions.Save(settingsNode.GetSubNode(nameof(this.ReconnectOptions), true)); this.CommonOptions.Save(settingsNode.GetSubNode(nameof(this.CommonOptions), true)); }
public static void Load(ISettingsNode node) { #pragma warning disable MEN010 // Avoid magic numbers. Default minutes and seconds values are clear in context. MaxWorkTime = TimeSpan.FromMinutes(node.GetValue("MaxWorkMinutes", 30)); MinBreakTime = TimeSpan.FromSeconds(node.GetValue("MinBreakSeconds", 30)); ShowProgress = node.GetValue(nameof(ShowProgress), true); PlaySound = node.GetValue(nameof(PlaySound), false); StartScreenSaver = node.GetValue(nameof(StartScreenSaver), false); ScreenSaverDelay = TimeSpan.FromMinutes(node.GetValue("ScreenSaverDelayMinutes", 3)); SnoozeTime = TimeSpan.FromMinutes(node.GetValue("SnoozeMinutes", 3)); #pragma warning restore MEN010 // Avoid magic numbers }
public static void Save(ISettingsNode node) { node.SetValue("CompareType", CompareType); node.SetValue("ShowWSInMainDiff", showWSInMainDiff); node.SetValue("ShowWSInLineDiff", showWSInLineDiff); node.SetValue("IgnoreCase", IgnoreCase); node.SetValue("IgnoreTextWhitespace", IgnoreTextWhitespace); node.SetValue("ShowOnlyInA", ShowOnlyInA); node.SetValue("ShowOnlyInB", ShowOnlyInB); node.SetValue("ShowDifferent", ShowDifferent); node.SetValue("ShowSame", ShowSame); node.SetValue("Recursive", Recursive); node.SetValue("IgnoreDirectoryComparison", IgnoreDirectoryComparison); node.SetValue("OnlyShowFileDialogIfShiftPressed", OnlyShowFileDialogIfShiftPressed); node.SetValue("OnlyShowDirDialogIfShiftPressed", OnlyShowDirDialogIfShiftPressed); node.SetValue("GoToFirstDiff", GoToFirstDiff); node.SetValue("CheckFileExists", checkFileExists); node.SetValue("CheckDirExists", checkDirExists); node.SetValue("ShowChangeAsDeleteInsert", ShowChangeAsDeleteInsert); node.SetValue("IgnoreXmlWhitespace", IgnoreXmlWhitespace); node.SetValue("ShowMdiTabs", showMdiTabs); node.SetValue("HashType", hashType); node.SetValue("LineDiffHeight", LineDiffHeight); node.SetValue("BinaryFootprintLength", BinaryFootprintLength); node.SetValue("LastFileA", LastFileA); node.SetValue("LastFileB", LastFileB); node.SetValue("LastDirA", LastDirA); node.SetValue("LastDirB", LastDirB); /* Note: We don't save or load the last text. */ node.SetValue("FontName", viewFont.Name); node.SetValue("FontStyle", viewFont.Style); node.SetValue("FontSize", Convert.ToString(viewFont.SizeInPoints)); // Save custom filters if (node.GetSubNode("Custom Filters", false) != null) { node.DeleteSubNode("Custom Filters"); } if (customFilters.Count > 0) { node = node.GetSubNode("Custom Filters", true); for (int i = 0; i < customFilters.Count; i++) { node.SetValue(i.ToString(), customFilters[i]); } } }
public ISettingsNode Transform([CanBeNull] ISettingsNode node) { ISettingsNode transformedNode; switch (node) { case ObjectNode objectNode: if (TryTransform(objectNode, out transformedNode)) { return(transformedNode); } var builder = new ObjectNodeBuilder(objectNode.Name); var transformedAnything = false; foreach (var child in objectNode.Children) { var transformedChild = Transform(child); if (transformedChild != null) { builder.SetChild(transformedChild); } if (!ReferenceEquals(child, transformedChild)) { transformedAnything = true; } } return(transformedAnything ? builder.Build() : objectNode); case ArrayNode arrayNode: if (TryTransform(arrayNode, out transformedNode)) { return(transformedNode); } var transformedChildren = arrayNode.Children.Select(Transform).Where(t => t != null).ToArray(); if (transformedChildren.SequenceEqual(arrayNode.Children, ByReferenceEqualityComparer <ISettingsNode> .Instance)) { return(arrayNode); } return(new ArrayNode(arrayNode.Name, transformedChildren)); case ValueNode valueNode: return(TryTransform(valueNode, out transformedNode) ? transformedNode : valueNode); default: return(node); } }
public void SetUp() { var boolBinder = Substitute.For <ISafeSettingsBinder <object> >(); boolBinder.Bind(Arg.Is <ISettingsNode>(n => n is ValueNode && ((ValueNode)n).Value == "true")) .Returns(SettingsBindingResult.Success <object>(true)); boolBinder.ReturnsForAll(_ => SettingsBindingResult.Error <object>(":(")); provider = Substitute.For <ISettingsBinderProvider>(); provider.CreateFor(typeof(bool)).Returns(boolBinder); settings = new ValueNode("true"); }