// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Xml.Serialization;
|
using System.Reflection;
|
using System.Collections.ObjectModel;
|
using System.Collections.Specialized;
|
using System.Collections;
|
using System.IO;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// <see cref="ComponentSettings"/> with this attribute belong to a group with a specified name.
|
/// They can be marked as profile groups, enabling selectable profiles for settings in that group.
|
/// </summary>
|
[AttributeUsage(AttributeTargets.Class)]
|
public class SettingsGroupAttribute : Attribute
|
{
|
/// <summary>
|
/// Name of the settings group.
|
/// </summary>
|
public string GroupName { get; }
|
/// <summary>
|
/// Specifies whether this settings group uses profiles.
|
/// </summary>
|
public bool Profile { get; }
|
|
/// <summary>
|
/// Constructor for <see cref="SettingsGroupAttribute"/>
|
/// </summary>
|
/// <param name="GroupName">The name of the settings group.</param>
|
/// <param name="Profile">If this settings group should use profiles.</param>
|
public SettingsGroupAttribute(string GroupName, bool Profile = true)
|
{
|
this.GroupName = GroupName;
|
this.Profile = Profile;
|
}
|
}
|
|
/// <summary>
|
/// Attribute that determines if the settings list should be fixed.
|
/// </summary>
|
[AttributeUsage(AttributeTargets.Class)]
|
public class FixedSettingsListAttribute : Attribute
|
{
|
}
|
|
internal interface IComponentSettingsList : IList
|
{
|
/// <summary> Return the objects which have been removed but still alive (non-GC'd) resources.
|
/// This requires using a list of WeakReferences.</summary>
|
IResource[] GetRemovedAliveResources();
|
}
|
|
///<summary>
|
/// Contains some extra functionality for the ComponentSettingsList.
|
/// Created so that it is possible to know which (generic) ComponentSettingsList
|
/// contains a given type.
|
/// </summary>
|
public static class ComponentSettingsList
|
{
|
static Dictionary<Type, Type> typeHandlersCache;
|
|
static Dictionary<Type, Type> typeHandlers
|
{
|
get
|
{
|
if (typeHandlersCache == null)
|
{
|
typeHandlersCache = new Dictionary<Type, Type>();
|
foreach (Type settingsType in PluginManager.GetPlugins(typeof(ComponentSettings)))
|
{
|
Type baseType = settingsType;
|
while (baseType != typeof(object))
|
{
|
baseType = baseType.BaseType;
|
if (baseType.IsGenericType && baseType.GetGenericTypeDefinition() == typeof(ComponentSettingsList<,>))
|
{
|
Type[] types = settingsType.BaseType.GetGenericArguments();
|
if (types.Length == 2)
|
{
|
typeHandlersCache[types[1]] = types[0];
|
break;
|
}
|
}
|
}
|
}
|
}
|
return typeHandlersCache;
|
}
|
}
|
|
/// <summary>
|
/// Gets the GetCurrent method for the container for type T.
|
/// Null if no such container.
|
/// </summary>
|
/// <param name="T"></param>
|
/// <returns></returns>
|
static PropertyInfo getGetCurrentMethodForContainer(Type T)
|
{
|
return getGetCurrentMethodsForContainer(T).FirstOrDefault();
|
}
|
|
static IEnumerable<PropertyInfo> getGetCurrentMethodsForContainer(Type T)
|
{
|
if (T == null)
|
throw new ArgumentNullException("T");
|
foreach (Type key in typeHandlers.Keys)
|
{
|
if (T.DescendsTo(key))
|
{
|
|
Type compSetType = typeHandlers[key];
|
if (GetCurrentProp(compSetType) is { } prop)
|
yield return prop;
|
}
|
}
|
}
|
|
private static PropertyInfo GetCurrentProp(Type compSetType)
|
{
|
return compSetType.GetProperty("Current", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
|
}
|
|
private static IList GetCurrent(Type compSetType)
|
{
|
if (GetCurrentProp(compSetType) is {} prop)
|
return (IList)prop.GetValue(null, null);
|
return null;
|
}
|
|
/// <summary>
|
/// Finds a ComponentSettingsList containing instances of T.
|
/// </summary>
|
/// <param name="T"></param>
|
/// <returns>A List of type T. Null if no ComponentSettingsList exists containing T.</returns>
|
public static IList GetContainer(Type T)
|
{
|
var m = getGetCurrentMethodForContainer(T);
|
if (m == null) return null;
|
return (IList)m.GetValue(null, null);
|
}
|
|
internal static IEnumerable<IList> GetResourceContainers()
|
{
|
foreach (Type key in typeHandlers.Keys)
|
{
|
if (!key.DescendsTo(typeof(IResource))) continue;
|
Type compSetType = typeHandlers[key];
|
if (GetCurrent(compSetType) is IList lst)
|
yield return lst;
|
}
|
}
|
|
/// <summary>
|
/// For checking if there is a ComponentSettings for T without evaluating GetCurrent.
|
/// </summary>
|
/// <param name="T"></param>
|
/// <returns></returns>
|
internal static bool HasContainer(Type T)
|
{
|
return getGetCurrentMethodForContainer(T) != null;
|
}
|
|
/// <summary>
|
/// Gets the ComponentSettings list for T and filters the instances that are not T.
|
/// </summary>
|
/// <returns></returns>
|
public static IList<T> GetItems<T>()
|
{
|
IList items = GetContainer(typeof(T));
|
if (items == null) return new List<T>();
|
return items.OfType<T>().ToList();
|
}
|
/// <summary>
|
/// (non-generic) Gets the ComponentSettings list for T and filters the instances that are not T.
|
/// </summary>
|
/// <param name="T"></param>
|
/// <returns></returns>
|
public static IList GetItems(Type T)
|
{
|
var container = GetContainer(T);
|
if (container == null) return new List<object>();
|
return container.Cast<object>().Where(v => v.GetType().DescendsTo(T)).ToList();
|
}
|
|
}
|
|
/// <summary>
|
/// ComponentSettingsList is a collection of objects. This is the case for DutSettings, for instance.
|
/// Uses IObservableCollection so that changes can be monitored.
|
/// </summary>
|
/// <typeparam name="DerivedType"></typeparam>
|
/// <typeparam name="ContainedType"></typeparam>
|
public abstract class ComponentSettingsList<DerivedType, ContainedType> : ComponentSettings<DerivedType>,
|
INotifyCollectionChanged, IList, IList<ContainedType>, IComponentSettingsList
|
where DerivedType : ComponentSettingsList<DerivedType, ContainedType>
|
{
|
readonly ObservableCollection<ContainedType> list;
|
readonly IList ilist;
|
|
// Keep track of all the still living, but previously touched objects.
|
// this is only used if ContainedType is a resource type.
|
private readonly WeakHashSet<IResource> touchedResources = new WeakHashSet<IResource>();
|
|
/// <summary>
|
/// Gets the first or default instance in the component settings list.
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <returns></returns>
|
public T GetDefault<T>() where T : ContainedType
|
{
|
return GetDefaultOf<T>();
|
}
|
/// <summary>
|
/// Static Get first or default instance in the component settings list. (uses GetCurrent)
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <returns></returns>
|
public static T GetDefaultOf<T>() where T : ContainedType => GetCurrent<DerivedType>().OfType<T>().FirstOrDefault();
|
|
/// <summary>
|
/// Initializes the list.
|
/// </summary>
|
public ComponentSettingsList()
|
{
|
list = new ObservableCollection<ContainedType>();
|
list.CollectionChanged += OnCollectionChanged;
|
ilist = list;
|
}
|
|
IResource[] IComponentSettingsList.GetRemovedAliveResources()
|
{
|
return touchedResources.GetElements().Where(x => Contains(x) == false).ToArray();
|
}
|
|
/// <summary> This gets invoked when the collection is changed. </summary>
|
internal protected virtual void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
{
|
if (e.Action == NotifyCollectionChangedAction.Add)
|
{
|
var _newItem = e.NewItems.Cast<ContainedType>().First();
|
if (_newItem is IResource newItem)
|
{
|
this.touchedResources.Add(newItem);
|
var sameName = this.FirstOrDefault(itm => (itm as IResource).Name == newItem.Name && (itm as IResource) != newItem);
|
int number = 0;
|
while (sameName != null)
|
{
|
number++;
|
sameName = this.FirstOrDefault(itm => (itm as IResource).Name == newItem.Name + number && (itm as IResource) != newItem);
|
}
|
if (number > 0)
|
{
|
newItem.Name += number;
|
}
|
}
|
}
|
CollectionChanged?.Invoke(sender, e);
|
OnPropertyChanged(nameof(Count));
|
}
|
/// <summary>
|
/// Adds an element to the collection.
|
/// </summary>
|
/// <param name="item"></param>
|
public void Add(ContainedType item)
|
{
|
list.Add(item);
|
}
|
|
/// <summary> Adds a number of elements to the collection. </summary>
|
/// <param name="items">The items to add to the list.</param>
|
public void AddRange(IEnumerable<ContainedType> items)
|
{
|
foreach (var item in items)
|
Add(item);
|
}
|
|
/// <summary>
|
/// Removes all elements from the collection.
|
/// </summary>
|
public void Clear()
|
{
|
list.Clear();
|
}
|
/// <summary>
|
/// Determines if the collection contains the specified element.
|
/// </summary>
|
/// <param name="item"></param>
|
/// <returns></returns>
|
public bool Contains(ContainedType item)
|
{
|
return list.Contains(item);
|
}
|
/// <summary>
|
/// Copies the collection to a compatible array.
|
/// </summary>
|
/// <param name="array"></param>
|
/// <param name="arrayIndex"></param>
|
public void CopyTo(ContainedType[] array, int arrayIndex)
|
{
|
list.CopyTo(array, arrayIndex);
|
}
|
/// <summary>
|
/// Gets the number of elements in the collection.
|
/// </summary>
|
public int Count
|
{
|
get { return list.Count; }
|
}
|
/// <summary>
|
/// Determines if the collection is read only.
|
/// </summary>
|
public bool IsReadOnly
|
{
|
get { return false; }
|
}
|
/// <summary>
|
/// Removes the first occurrence of a specified element from the collection.
|
/// </summary>
|
/// <param name="item"></param>
|
/// <returns></returns>
|
public bool Remove(ContainedType item)
|
{
|
return list.Remove(item);
|
}
|
/// <summary>
|
/// Returns an <see cref="IEnumerator"/> that iterates through the collection.
|
/// </summary>
|
/// <returns></returns>
|
public IEnumerator<ContainedType> GetEnumerator()
|
{
|
return list.GetEnumerator();
|
}
|
/// <summary>
|
/// Returns an <see cref="IEnumerator"/> that iterates through the collection.
|
/// </summary>
|
/// <returns></returns>
|
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
|
{
|
return GetEnumerator();
|
}
|
/// <summary>
|
/// Returns the index of the first occurrences of a specified element in the collection.
|
/// </summary>
|
/// <param name="item"></param>
|
/// <returns></returns>
|
public int IndexOf(ContainedType item)
|
{
|
return list.IndexOf(item);
|
}
|
/// <summary>
|
/// Insert an element into the collection at the specified index.
|
/// </summary>
|
/// <param name="index"></param>
|
/// <param name="item"></param>
|
public void Insert(int index, ContainedType item)
|
{
|
list.Insert(index, item);
|
}
|
/// <summary>
|
/// Removes an element at a specified index.
|
/// </summary>
|
/// <param name="index"></param>
|
public void RemoveAt(int index)
|
{
|
list.RemoveAt(index);
|
}
|
/// <summary>
|
/// List interface
|
/// </summary>
|
/// <param name="index"></param>
|
/// <returns></returns>
|
[XmlIgnore]
|
public ContainedType this[int index]
|
{
|
get
|
{
|
return list[index];
|
}
|
set
|
{
|
list[index] = value;
|
}
|
}
|
|
|
/// <summary>
|
/// Invoked when collection is changed.
|
/// </summary>
|
public event NotifyCollectionChangedEventHandler CollectionChanged;
|
|
/// <summary>
|
/// Adds an element to the collection.
|
/// </summary>
|
/// <param name="value"></param>
|
/// <returns></returns>
|
public int Add(object value)
|
{
|
return ilist.Add(value);
|
}
|
/// <summary>
|
/// Determines if the collection contains the specified element.
|
/// </summary>
|
/// <param name="value"></param>
|
/// <returns></returns>
|
public bool Contains(object value)
|
{
|
return ilist.Contains(value);
|
}
|
/// <summary>
|
/// Returns the index of the first occurrences of a specified element in the collection.
|
/// </summary>
|
/// <param name="value"></param>
|
/// <returns></returns>
|
public int IndexOf(object value)
|
{
|
return ilist.IndexOf(value);
|
}
|
/// <summary>
|
/// Insert an element into the collection at the specified index.
|
/// </summary>
|
/// <param name="index"></param>
|
/// <param name="value"></param>
|
public void Insert(int index, object value)
|
{
|
ilist.Insert(index, value);
|
}
|
/// <summary>
|
/// Determines if the collection is fixed size.
|
/// </summary>
|
public bool IsFixedSize
|
{
|
get { return ilist.IsFixedSize; }
|
}
|
|
/// <summary>
|
/// Removes the first occurrence of a specified element from the collection.
|
/// </summary>
|
/// <param name="value"></param>
|
public void Remove(object value)
|
{
|
ilist.Remove(value);
|
}
|
/// <summary>
|
/// List interface
|
/// </summary>
|
/// <param name="index"></param>
|
/// <returns></returns>
|
object IList.this[int index]
|
{
|
get
|
{
|
return ilist[index];
|
}
|
set
|
{
|
ilist[index] = value;
|
}
|
}
|
/// <summary>
|
/// Copies the collection to a compatible array.
|
/// </summary>
|
/// <param name="array"></param>
|
/// <param name="index"></param>
|
public void CopyTo(Array array, int index)
|
{
|
ilist.CopyTo(array, index);
|
}
|
/// <summary>
|
/// Determines if the collection is synchronized.
|
/// </summary>
|
public bool IsSynchronized
|
{
|
get { return ilist.IsSynchronized; }
|
}
|
/// <summary>
|
/// Gets an object that can be used to synchronize access the collection.
|
/// </summary>
|
public object SyncRoot
|
{
|
get { return ilist.SyncRoot; }
|
}
|
}
|
|
/// <summary>
|
/// It is recommended to inherit from this class when implementing component settings.
|
/// This class uses a recurrent template pattern to exhibit a kind of "static reflection".
|
/// </summary>
|
/// <remarks>
|
/// It is also possible implement a component setting by inherriting from the non-generic <see cref="ComponentSettings"/>
|
/// or <see cref="IComponentSettings"/> it is just not recommended.
|
/// </remarks>
|
/// <typeparam name="T">The inheriting class.</typeparam>
|
public abstract class ComponentSettings<T> : ComponentSettings
|
where T : ComponentSettings
|
{
|
|
///<summary>
|
/// Gets the current setting of a specific type.
|
/// </summary>
|
/// <returns></returns>
|
internal static T GetCurrent() => GetCurrent<T>();
|
|
/// <summary>
|
/// Get the currently loaded ComponentSettings instance for this class.
|
/// </summary>
|
public static T Current => GetCurrent();
|
|
internal static T CurrentFromCache => (T)GetCurrentFromCache(typeof(T));
|
}
|
|
/// <summary>
|
/// Specifies the ComponentSettings class to be a OpenTAP plugin.
|
/// </summary>
|
/// <remarks>
|
/// It is recommended to inherit from <see cref="ComponentSettings{T}"/> when possible.
|
/// </remarks>
|
[Display("Component Settings")]
|
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
public interface IComponentSettings : ITapPlugin
|
{
|
|
}
|
|
/// <summary>
|
/// An abstract class to implement general settings for a component.
|
/// This class provides methods to load and save the settings to/from an XML file using TapSerializer.
|
/// </summary>
|
/// <remarks>
|
/// It is recommended to inherit from <see cref="ComponentSettings{T}"/> when possible.
|
/// </remarks>
|
public abstract class ComponentSettings : ValidatingObject, IComponentSettings
|
{
|
internal XmlError[] loadErrors;
|
string groupName;
|
/// <summary> Settings group of this settings class. </summary>
|
public string GroupName
|
{
|
get
|
{
|
if (groupName != null) return groupName;
|
var settingsGroup = GetType().GetAttribute<SettingsGroupAttribute>();
|
groupName = settingsGroup == null ? "" : settingsGroup.GroupName;
|
|
return groupName;
|
}
|
}
|
|
internal bool profile
|
{
|
get
|
{
|
var settingsGroup = GetType().GetAttribute<SettingsGroupAttribute>();
|
if (settingsGroup == null) return false;
|
return settingsGroup.Profile;
|
}
|
}
|
|
/// <summary>
|
/// Invokes when the cache for this settings item is invalidated for this item.
|
/// The way to handle it is usually to fetch the new instance using ComponentSettings.GetCurrent(sender.GetType()).
|
/// </summary>
|
public event EventHandler CacheInvalidated;
|
/// <summary>
|
/// Where settings files are located.
|
/// Usually this is at "[Executable location]\Settings", but it can be set to different locations.
|
/// Setting this will invalidate loaded settings.
|
/// </summary>
|
public static string SettingsDirectoryRoot
|
{
|
get => context.SettingsDirectoryRoot;
|
set => context.SettingsDirectoryRoot = value;
|
}
|
|
/// <summary> The directory where the settings are loaded from / saved to. </summary>
|
/// <param name="groupName">Name of the settings group.</param>
|
/// <param name="isProfile">If the settings group uses profiles, we load the default profile.</param>
|
public static string GetSettingsDirectory(string groupName, bool isProfile = true) =>
|
context.GetSettingsDirectory(groupName, isProfile);
|
|
/// <summary>
|
/// Ensures that the Settings directory exists and that the specified groupName sub directory exists.
|
/// This might throw an exception if the settings directory was configured to something invalid. Like 'AUX', 'NUL', ....
|
/// </summary>
|
/// <param name="groupName">Name of the settings group.</param>
|
/// <param name="isProfile">Determines if the settings group uses profiles.</param>
|
public static void EnsureSettingsDirectoryExists(string groupName, bool isProfile = true) =>
|
context.EnsureSettingsDirectoryExists(groupName, isProfile);
|
/// <summary> Gets or sets if settings groups should be persisted between processes.</summary>
|
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
public static bool PersistSettingGroups = true;
|
|
/// <summary> Sets the directory in which settings groups are loaded from / saved to. </summary>
|
/// <param name="groupName">Name of the settings group.</param>
|
/// <param name="profileName">Name of the selected settings profile.</param>
|
public static void SetSettingsProfile(string groupName, string profileName) =>
|
context.SetSettingsProfile(groupName, profileName);
|
|
/// <summary> Invalidates all loaded settings. Next time a ComponentSettings is accessed, it will be read from an XML file. </summary>
|
internal static void InvalidateAllSettings() => context.InvalidateAllSettings();
|
|
|
static ComponentSettingsContext context => sessionContext.Value;
|
static readonly SessionLocal<ComponentSettingsContext> sessionContext = new SessionLocal<ComponentSettingsContext>(new ComponentSettingsContext());
|
|
internal static void BeginSession()
|
{
|
var currentContext = context;
|
var nextContext = currentContext.Clone();
|
nextContext.readOnlyContext = true;
|
sessionContext.Value = nextContext;
|
}
|
|
/// <summary>
|
/// Saves the settings held by this class to an XML file in the <see cref="ComponentSettings.SetSettingsProfile(string, string)"/>.
|
/// </summary>
|
public void Save() => context.Save(this);
|
|
/// <summary> Saves all ComponentSettings objects that have been loaded. </summary>
|
public static void SaveAllCurrentSettings() => context.SaveAllCurrentSettings();
|
|
/// <summary>
|
/// Invalidates the cache of this type of component setting.
|
/// </summary>
|
public void Invalidate() => context.Invalidate(GetType());
|
|
/// <summary>
|
/// Forces the reload of this type of component setting from the XML file the next time the setting is used.
|
/// </summary>
|
public void Reload() => context.Reload();
|
|
/// <summary>
|
/// Called if a new ComponentSettings is instantiated and there are no corresponding settings XML.
|
/// </summary>
|
public virtual void Initialize()
|
{
|
|
}
|
|
/// <summary> Gets the current file location where a ComponentSettings type is saved. </summary>
|
/// <param name="type"> Must be a ComponentSettings sub-class. </param>
|
/// <returns></returns>
|
public static string GetSaveFilePath(Type type) => context.GetSaveFilePath(type);
|
|
/// <summary>
|
/// Gets current settings for a specified component. This is either an instance of the settings class previously loaded, or a new instance loaded from the associated file.
|
/// </summary>
|
/// <typeparam name="T">The type of the component settings requested (this type must be a descendant of <see cref="ComponentSettings"/>).</typeparam>
|
/// <returns>Returns the loaded components settings. Null if it was not able to load the settings type.</returns>
|
internal static T GetCurrent<T>() where T : ComponentSettings => (T)GetCurrent(typeof(T));
|
|
/// <summary>
|
/// Gets current settings for a specified component. This is either an instance of the settings class previously loaded, or a new instance loaded from the associated file.
|
/// </summary>
|
/// <param name="settingsType">The type of the component settings requested (this type must be a descendant of <see cref="ComponentSettings"/>).</param>
|
/// <returns>Returns the loaded components settings. Null if it was not able to load the settings type.</returns>
|
public static ComponentSettings GetCurrent(Type settingsType) =>
|
context.GetCurrent(settingsType);
|
|
/// <summary>
|
/// Sets current settings for a component setting based on a stream of the file contents of a ComponentSettings XML file.
|
/// </summary>
|
/// <exception cref="InvalidDataException">If the input stream is not valid XML</exception>
|
/// <param name="xmlFileStream">The component settings stream to be set</param>
|
/// <returns></returns>
|
public static void SetCurrent(Stream xmlFileStream) => context.SetCurrent(xmlFileStream);
|
|
/// <summary>
|
/// Sets current settings for a component setting based on a stream of the file contents of a ComponentSettings XML file.
|
/// </summary>
|
/// <param name="xmlFileStream">The component settings stream to be set</param>
|
/// <param name="errors">Any XML errors that occurred during deserialization</param>
|
/// <returns></returns>
|
public static void SetCurrent(Stream xmlFileStream, out IEnumerable<XmlError> errors) => context.SetCurrent(xmlFileStream, out errors);
|
|
/// <summary>
|
/// Gets current settings for a specified component. This is either an instance of the settings class previously loaded, or a new instance loaded from the associated file.
|
/// </summary>
|
/// <param name="settingsType">The type of the component settings requested (this type must be a descendant of <see cref="ComponentSettings"/>).</param>
|
/// <returns>Returns the loaded components settings. Null if it was not able to load the settings type.</returns>
|
public static ComponentSettings GetCurrent(ITypeData settingsType)
|
{
|
var td = settingsType.AsTypeData()?.Type;
|
// in some rare cases, the type can be null
|
// for example if the assembly could not be loaded(32/64bit incompatible), but it could be reflected.
|
// in this case just return null.
|
if (td == null)
|
return null;
|
return context.GetCurrent(td);
|
}
|
|
/// <summary>
|
/// Gets current settings for a specified component from cache.
|
/// </summary>
|
/// <param name="settingsType">The type of the component settings requested (this type must be a descendant of <see cref="ComponentSettings"/>).</param>
|
/// <returns>Returns the loaded components settings. Null if it was not able to load the settings type or if it was not cached.</returns>
|
public static ComponentSettings GetCurrentFromCache(Type settingsType) =>
|
context.GetCurrentFromCache(settingsType);
|
|
internal void InvokeInvalidate()
|
{
|
CacheInvalidated?.Invoke(this, EventArgs.Empty);
|
}
|
}
|
}
|
