// 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;
|
using System.Collections.Concurrent;
|
using System.Collections.Generic;
|
using System.Globalization;
|
using System.Linq;
|
using System.Security;
|
using System.Text;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Plugin interface for string convert providers.
|
/// </summary>
|
/// <remarks>
|
/// FromString(GetString(value), value.GetType()) shall always return a non-null value, if GetString(value) returns a non-null value.
|
/// </remarks>
|
[Display("String Converter")]
|
public interface IStringConvertProvider : ITapPlugin
|
{
|
/// <summary>
|
/// Returns a string when the implementation supports converting the value. Otherwise, returns null.
|
/// </summary>
|
/// <param name="value">Cannot be null.</param>
|
/// <param name="culture">The culture used for the conversion.</param>
|
/// <returns></returns>
|
string GetString(object value, CultureInfo culture);
|
/// <summary>
|
/// Creates an object from stringdata. The returned object should be of type 'type'. Returns null if it cannot convert stringdata to type.
|
/// </summary>
|
/// <param name="stringData"></param>
|
/// <param name="type"></param>
|
/// <param name="contextObject">The object on which the value is set.</param>
|
/// <param name="culture">The culture used for the conversion. This value can will default to InvariantCulture if nothing else is selected.</param>
|
/// <returns></returns>
|
object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture);
|
}
|
|
/// <summary>
|
/// Helper methods for converting to/from strings.
|
/// </summary>
|
public static class StringConvertProvider
|
{
|
static class PluginTypeFetcher<T>
|
{
|
static readonly Dictionary<ITypeData, T> saveTypes = new Dictionary<ITypeData, T>();
|
static T[] things = Array.Empty<T>();
|
public static T[] GetPlugins()
|
{
|
var derivedTypes = TypeData.GetDerivedTypes<T>();
|
|
int count = derivedTypes.Count(x => x.CanCreateInstance);
|
|
if (count != saveTypes.Count)
|
{
|
lock (saveTypes)
|
{
|
if (count != saveTypes.Count)
|
{
|
var builder = things.ToList();
|
Dictionary<T, BeforeAttribute[]> orderings = new Dictionary<T, BeforeAttribute[]>();
|
|
foreach (var type in derivedTypes)
|
{
|
if (type.CanCreateInstance == false) continue;
|
|
if (saveTypes.ContainsKey(type) == false)
|
{
|
try
|
{
|
var newthing = (T)type.CreateInstance();
|
saveTypes.Add(type, newthing);
|
|
// if BeforeAttribute is used, insert somewhere before the marked type.
|
// otherwise insert at the end of the list.
|
int addIndex = builder.Count;
|
var ordering = type.GetAttributes<BeforeAttribute>().ToArray();
|
orderings[newthing] = ordering;
|
foreach (var before in ordering)
|
{
|
int addIndex2 = builder.IndexWhen(item => before.Before(TypeData.GetTypeData(item)));
|
if (addIndex2 != -1 && addIndex2 < addIndex)
|
addIndex = addIndex2;
|
}
|
|
builder.Insert(addIndex, newthing);
|
}
|
catch
|
{
|
saveTypes[type] = default(T);
|
} // Ignore errors here.
|
}
|
}
|
|
// iterate to find the correct ordering.
|
// this is a bit akin to bubble sorting, but the chance that these dependenceny chains gets very long is limited.
|
{
|
HashSet<(T, T)> swapPairs = new HashSet<(T, T)>();
|
|
for (int i = 0; i < builder.Count; i++)
|
{
|
int addIndex = i;
|
var type = builder[i];
|
foreach (var before in orderings[type])
|
{
|
int addIndex2 = builder.IndexWhen(item => before.Before(TypeData.GetTypeData(item)));
|
if (addIndex2 != -1 && addIndex2 < addIndex)
|
addIndex = addIndex2;
|
}
|
if (addIndex < i)
|
{
|
if (swapPairs.Add((builder[addIndex], builder[i])) == false)
|
throw new Exception("Circular dependency in BeforeAttribute"); // these has been swapped before - that means there is a circular dependency.
|
|
(builder[i], builder[addIndex]) = (builder[addIndex], builder[i]);
|
i = addIndex;
|
}
|
}
|
}
|
|
things = builder.ToArray();
|
}
|
}
|
}
|
|
return things;
|
}
|
}
|
|
class CachePopularity: IEnumerable<IStringConvertProvider>
|
{
|
class Wrap : IStringConvertProvider
|
{
|
IStringConvertProvider inner;
|
public long Popularity;
|
|
public Wrap(IStringConvertProvider inner)
|
{
|
this.inner = inner;
|
}
|
|
public string GetString(object value, CultureInfo culture)
|
{
|
var str = inner.GetString(value, culture);
|
if (str != null)
|
Popularity += 1;
|
return str;
|
}
|
|
public object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture)
|
{
|
object obj = inner.FromString(stringData, type, contextObject, culture);
|
if (obj != null)
|
Popularity += 1;
|
return obj;
|
}
|
}
|
|
readonly Wrap[] wrappers;
|
int[] popularityIndex;
|
|
public CachePopularity(IStringConvertProvider[] elements)
|
{
|
wrappers = elements.Select(x => new Wrap(x)).ToArray();
|
popularityIndex = new int[wrappers.Length];
|
for (int i = 0; i < wrappers.Length; i++)
|
popularityIndex[i] = i;
|
}
|
|
public IEnumerator<IStringConvertProvider> GetEnumerator()
|
{
|
var popularity = popularityIndex;
|
long prevPopularity = long.MaxValue;
|
for(int i = 0; i < popularity.Length; i++)
|
{
|
var item = popularity[i];
|
var wrap = wrappers[item];
|
if (i > 0 && wrap.Popularity / 4 > prevPopularity && popularityIndex == popularity)
|
{
|
var newIndex = popularity.ToArray();
|
Utils.Swap(ref newIndex[i], ref newIndex[i - 1]);
|
popularityIndex = newIndex;
|
}
|
|
prevPopularity = wrap.Popularity;
|
yield return wrap;
|
}
|
}
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
}
|
|
class StringConvertCacheOptimizer : ICacheOptimizer
|
{
|
|
static readonly ThreadField<CachePopularity> cacheField = new ThreadField<CachePopularity>();
|
public void LoadCache() => cacheField.Value = new CachePopularity(PluginTypeFetcher<IStringConvertProvider>.GetPlugins());
|
public void UnloadCache() => cacheField.Value = null;
|
public static IEnumerable<IStringConvertProvider> GetValue() => (IEnumerable<IStringConvertProvider>)cacheField.Value ?? PluginTypeFetcher<IStringConvertProvider>.GetPlugins();
|
|
}
|
|
static IEnumerable<IStringConvertProvider> Providers => StringConvertCacheOptimizer.GetValue();
|
|
/// <summary>
|
/// Turn value to a string if an IStringConvertProvider plugin supports the value. Returns null if the input value is null.
|
/// </summary>
|
/// <param name="value">The value to be converted to a string.</param>
|
/// <param name="culture">If null, invariant culture is used.</param>
|
/// <returns></returns>
|
public static string GetString(object value, CultureInfo culture = null)
|
{
|
if (value == null) return null;
|
if (value is string p) return p;
|
culture = culture ?? CultureInfo.InvariantCulture;
|
foreach(var provider in Providers)
|
{
|
try {
|
var str = provider.GetString(value, culture);
|
if (str != null)
|
{
|
return str;
|
}
|
}
|
catch { } // ignore errors. Assume unsupported value.
|
}
|
return value.ToString();
|
}
|
/// <summary>
|
/// Try get a string from an object value.
|
/// </summary>
|
/// <param name="value"></param>
|
/// <param name="str"></param>
|
/// <param name="culture"></param>
|
/// <returns></returns>
|
public static bool TryGetString(object value, out string str, CultureInfo culture = null)
|
{
|
str = null;
|
if (value == null) return false;
|
if (value is string p)
|
{
|
str = p;
|
return true;
|
}
|
culture = culture ?? CultureInfo.InvariantCulture;
|
foreach (var provider in Providers)
|
{
|
try
|
{
|
str = provider.GetString(value, culture);
|
if (str != null) return true;
|
}
|
catch { } // ignore errors. Assume unsupported value.
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// Turn stringdata back to an object of type 'type', if an IStringConvertProvider plugin supports the string/type.
|
/// </summary>
|
/// <param name="stringdata"></param>
|
/// <param name="type"></param>
|
/// <param name="contextObject"></param>
|
/// <param name="culture">If null, invariant culture is used.</param>
|
/// <returns></returns>
|
public static object FromString(string stringdata, ITypeData type, object contextObject, CultureInfo culture = null)
|
{
|
if (stringdata == null)
|
return null;
|
if (type == null)
|
throw new ArgumentNullException("type");
|
culture = culture ?? CultureInfo.InvariantCulture;
|
foreach (var provider in Providers)
|
{
|
try
|
{
|
var value = provider.FromString(stringdata, type, contextObject, culture);
|
if (value != null) return value;
|
}
|
catch
|
{
|
} // ignore errors. Assume unsupported value.
|
}
|
|
throw new FormatException(string.Format("Unable to parse '{0}' as a {1}.", stringdata, type));
|
}
|
|
/// <summary>
|
/// Turn stringdata back to an object of type 'type', if an IStringConvertProvider plugin supports the string/type. returns true if the parsing was successful.
|
/// </summary>
|
/// <param name="stringdata"></param>
|
/// <param name="type"></param>
|
/// <param name="contextObject"></param>
|
/// <param name="result">The result of the operation.</param>
|
/// <param name="culture"></param>
|
/// <returns></returns>
|
public static bool TryFromString(string stringdata, ITypeData type, object contextObject, out object result, CultureInfo culture = null)
|
{
|
if (type == null)
|
throw new ArgumentNullException("type");
|
|
result = null;
|
if (stringdata == null)
|
return false;
|
|
culture = culture ?? CultureInfo.InvariantCulture;
|
foreach (var provider in Providers)
|
{
|
try
|
{
|
var value = provider.FromString(stringdata, type, contextObject, culture);
|
if (value != null)
|
{
|
result = value;
|
return true;
|
}
|
}
|
catch
|
{
|
} // ignore errors. Assume unsupported value.
|
}
|
return false;
|
}
|
|
}
|
|
// All the IStringConvertProvider default implementations.
|
namespace Plugins
|
{
|
/// <summary> String Convert probider for IConvertible. </summary>
|
internal class ConvertibleStringConvertProvider : IStringConvertProvider
|
{
|
/// <summary> Returns an IConvertible if applicable. </summary>
|
public object FromString(string stringData, ITypeData _type, object contextObject, CultureInfo culture)
|
{
|
var type = (_type as TypeData)?.Type;
|
if (type == null) return null;
|
if (type == typeof(DateTime))
|
{
|
return DateTime.ParseExact(stringData, "yyyy-MM-dd HH-mm-ss", culture);
|
}
|
if (type.IsNumeric())
|
{
|
if(new NumberFormatter(culture).TryParseNumber(stringData, type, out object val))
|
{
|
return val;
|
}
|
return null;
|
}
|
else if (type == typeof(string))
|
return stringData;
|
else if(type == typeof(bool))
|
{
|
if (bool.TryParse(stringData, out bool value))
|
return value;
|
return null;
|
}
|
|
if (type.DescendsTo(typeof(IConvertible)) && type.IsEnum == false)
|
{
|
try
|
{
|
return Convert.ChangeType(stringData, type, culture);
|
}
|
catch
|
{
|
return null;
|
}
|
}
|
|
return null;
|
}
|
|
/// <summary> Turns an IConvertible into a string. </summary>
|
public string GetString(object value, CultureInfo culture)
|
{
|
if (value is Enum)
|
return null;
|
if (value is DateTime)
|
return ((DateTime)value).ToString("yyyy-MM-dd HH-mm-ss");
|
if (value is IConvertible)
|
return (string)Convert.ChangeType(value, typeof(string), culture);
|
|
return null;
|
}
|
}
|
|
/// <summary> String Convert for Enabled of T. </summary>
|
internal class EnabledStringConvertProvider : IStringConvertProvider
|
{
|
static Type GetEnabledElementType(Type enumType)
|
{
|
if (enumType.IsArray)
|
return enumType.GetElementType();
|
|
var ienumInterface = enumType.GetInterface("Enabled`1") ?? enumType;
|
if (ienumInterface != null)
|
return ienumInterface.GetGenericArguments().FirstOrDefault();
|
|
return typeof(object);
|
}
|
|
/// <summary> Creates an Enabled from a string. </summary>
|
public object FromString(string stringData, ITypeData _type, object contextObject, CultureInfo culture)
|
{
|
Type type = (_type as TypeData)?.Type;
|
if (type == null) return null;
|
if (type.DescendsTo(typeof(IEnabledValue)) == false)
|
return null;
|
stringData = stringData.Trim();
|
var disabled = "(disabled)";
|
IEnabledValue enabled = (IEnabledValue)Activator.CreateInstance(type);
|
var elemType = GetEnabledElementType(type);
|
if (stringData.StartsWith(disabled))
|
{
|
if (StringConvertProvider.TryFromString(stringData.Substring(disabled.Length).Trim(), TypeData.FromType(elemType), null, out object obj, culture))
|
enabled.Value = obj;
|
else return null;
|
enabled.IsEnabled = false;
|
}
|
else
|
{
|
if (StringConvertProvider.TryFromString(stringData, TypeData.FromType(elemType), null, out object obj, culture))
|
enabled.Value = obj;
|
else return null;
|
enabled.IsEnabled = true;
|
}
|
return enabled;
|
|
}
|
|
/// <summary> Turns Enabled into a string. </summary>
|
public string GetString(object value, CultureInfo culture)
|
{
|
if (value is IEnabledValue ev)
|
{
|
var inner = StringConvertProvider.GetString(ev.Value, culture);
|
if (inner == null) return null;
|
if (ev.IsEnabled)
|
return inner;
|
return "(disabled)" + inner;
|
}
|
return null;
|
}
|
}
|
|
/// <summary> String Convert for enums. </summary>
|
internal class EnumStringConvertProvider : IStringConvertProvider
|
{
|
static bool tryParseEnumString(string str, Type type, out Enum result)
|
{
|
result = null;
|
if (str == "")
|
{
|
result = (Enum)Enum.ToObject(type, 0);
|
return true;
|
}
|
if (str.Contains('|'))
|
{
|
var flagStrings = str.Split('|');
|
long flags = 0;
|
foreach (var flagString in flagStrings)
|
{
|
if (tryParseEnumString(flagString, type, out var result2))
|
flags |= (long)Convert.ChangeType(result2, TypeCode.Int64);
|
}
|
result = (Enum)Enum.ToObject(type, flags);
|
return true;
|
}
|
|
var names = Enum.GetNames(type);
|
//try
|
{ // Look for an exact match.
|
|
for(int i = 0; i < names.Length; i++)
|
{
|
if(names[i] == str)
|
{
|
result = (Enum)Enum.GetValues(type).GetValue(i);
|
return true;
|
}
|
}
|
|
// try to match display name.
|
for (int i = 0; i < names.Length; i++)
|
{
|
var display = type.GetMember(names[i]).Select(x => x.GetDisplayAttribute()).FirstOrDefault();
|
if (StringComparer.OrdinalIgnoreCase.Equals(display.Name, str))
|
{
|
result = (Enum)Enum.GetValues(type).GetValue(i);
|
return true;
|
}
|
}
|
}
|
|
|
{// try a more robust parse method. (tolower, trim, '_'=' ')
|
|
str = str.Trim().ToLower();
|
var fixedNames = names.Select(name => name.Trim().ToLower()).ToArray();
|
for (int i = 0; i < fixedNames.Length; i++)
|
{
|
if (fixedNames[i] == str || fixedNames[i].Replace('_', ' ') == str)
|
{
|
result = (Enum)Enum.GetValues(type).GetValue(i);
|
return true;
|
}
|
}
|
// Repeat the robust parse for display names
|
for (int i = 0; i < names.Length; i++)
|
{
|
var display = type.GetMember(names[i]).Select(x => x.GetDisplayAttribute()).FirstOrDefault();
|
var name = display.Name.ToLower().Trim();
|
if (StringComparer.OrdinalIgnoreCase.Equals(name, str) ||
|
StringComparer.OrdinalIgnoreCase.Equals(name.Replace('_', ' '), str))
|
{
|
result = (Enum) Enum.GetValues(type).GetValue(i);
|
return true;
|
}
|
}
|
}
|
result = null;
|
return false;
|
}
|
|
/// <summary> Creates an enum from a string. </summary>
|
public object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture)
|
{
|
if (type is TypeData cst)
|
{
|
if (false == cst.Type.IsEnum) return null;
|
Enum result;
|
if (tryParseEnumString(stringData, cst.Type, out result) == false)
|
return null;
|
return result;
|
}
|
return null;
|
}
|
|
static Dictionary<Type, Array> isFlagsAttribute = new Dictionary<Type, Array>();
|
static Array getFlagsValues(Type t)
|
{
|
lock (isFlagsAttribute)
|
{
|
if (isFlagsAttribute.TryGetValue(t, out Array isFlagsValue))
|
return isFlagsValue;
|
|
Array values = t.HasAttribute<FlagsAttribute>() ? Enum.GetValues(t) : null;
|
isFlagsAttribute[t] = values;
|
return values;
|
}
|
}
|
|
static ConcurrentDictionary<Enum, string> enumToStringCache = new ConcurrentDictionary<Enum, string>();
|
|
public string GetString(object value, CultureInfo culture)
|
{
|
if (value is Enum e)
|
{
|
if (enumToStringCache.TryGetValue(e, out var conv))
|
return conv;
|
conv = getString(e);
|
enumToStringCache[e] = conv;
|
return conv;
|
}
|
|
return null;
|
}
|
|
/// <summary> Turns an enum into a string. Usually just ToString unless flags. </summary>
|
static string getString(Enum val)
|
{
|
if (getFlagsValues(val.GetType()) is Array values)
|
{
|
StringBuilder sb = new StringBuilder();
|
bool first = true;
|
foreach (Enum flag in values)
|
{
|
if (val.HasFlag(flag))
|
{
|
if (first)
|
first = false;
|
else
|
sb.Append('|');
|
sb.Append(flag);
|
}
|
}
|
return sb.ToString();
|
}
|
return val.ToString();
|
}
|
}
|
|
/// <summary> String convert for list/IEnumerable types. </summary>
|
internal class ListStringConvertProvider : IStringConvertProvider
|
{
|
/// <summary> Creates a sequence from string. </summary>
|
public object FromString(string stringData, ITypeData _type, object contextObject, CultureInfo culture)
|
{
|
var type = (_type as TypeData)?.Type;
|
if (type.DescendsTo(typeof(IEnumerable)) == false) return null;
|
if (type.DescendsTo(typeof(string))) return null;
|
|
var elemType = type.GetEnumerableElementType();
|
if (elemType == null) return null;
|
|
Array seq = null;
|
if (elemType.IsNumeric())
|
{
|
var fmt = new NumberFormatter(culture);
|
var data = fmt.Parse(stringData);
|
if (data.GetType().DescendsTo(type))
|
return data;
|
seq = data.CastTo(elemType).Cast<object>().ToArray();
|
}
|
else
|
{
|
// unescape nested strings and put them into 'parsedStrings'.
|
// after this they will be handled individually.
|
List<string> parsedStrings = new List<string>();
|
if (stringData.Length > 0)
|
{
|
StringBuilder buffer = new StringBuilder();
|
for (int i = 0; i < stringData.Length; i++)
|
{
|
var chr = stringData[i];
|
if (chr == ',')
|
{
|
parsedStrings.Add(buffer.ToString());
|
buffer.Clear();
|
continue;
|
}
|
|
if (chr == '"')
|
{
|
for (i += 1; i < stringData.Length; i++)
|
{
|
chr = stringData[i];
|
if (chr == '"')
|
{
|
if (stringData.Length > i + 1 && stringData[i + 1] == '"')
|
i += 1; // skip escaped quotes and remove extra \".
|
else break;
|
}
|
|
buffer.Append(chr);
|
}
|
}
|
else
|
{
|
buffer.Append(chr);
|
}
|
}
|
|
parsedStrings.Add(buffer.ToString());
|
}
|
|
var values = new List<object>();
|
foreach (var str in parsedStrings)
|
{
|
if (StringConvertProvider.TryFromString(str.Trim(), TypeData.FromType(elemType), null, out object e))
|
{
|
values.Add(e);
|
}
|
else
|
{
|
// cannot handle element -> give up.
|
return null;
|
}
|
}
|
seq = values.ToArray();
|
}
|
if (seq == null) return null;
|
if (type.IsArray)
|
{
|
var array = Array.CreateInstance(elemType, seq.Length);
|
int idx = 0;
|
foreach (var item in seq)
|
array.SetValue(item, idx++);
|
return array;
|
}
|
else if (type.GetConstructor([]) != null)
|
{
|
object lst = Activator.CreateInstance(type);
|
var add = type.GetMethodsTap().First(m => m.Name == "Add");
|
foreach (object item in seq)
|
add.Invoke(lst, new[] { item });
|
return lst;
|
}
|
else
|
{
|
return null;
|
}
|
|
}
|
|
NumberFormatter fmt = new NumberFormatter(CultureInfo.InvariantCulture) { UseRanges = false};
|
|
/// <summary> Turns a value into a string, </summary>
|
public string GetString(object value, CultureInfo culture)
|
{
|
/* return null if we do not know how to construct this type.
|
Another provider may be able to handle this, so this is fine.
|
*/
|
{
|
var type = value?.GetType();
|
if (type == null) return null;
|
if (type.DescendsTo(typeof(string))) return null;
|
if (type.IsArray == false && type.GetConstructor([]) == null) return null;
|
}
|
if (value is IEnumerable seq)
|
{
|
bool isNumeric = false;
|
foreach (var elem in seq)
|
{
|
isNumeric = true;
|
if (elem is Enum || Utils.IsNumeric(elem) == false)
|
{
|
isNumeric = false;
|
break;
|
}
|
}
|
|
if (isNumeric)
|
return fmt.FormatRange(seq);
|
|
string escapeString(string str)
|
{
|
if (str.Contains(",") || str.Contains("\""))
|
return $"\"{str.Replace("\"", "\"\"")}\"";
|
return str;
|
}
|
|
var sb = new StringBuilder();
|
bool first = true;
|
foreach (var val in seq)
|
{
|
|
if (StringConvertProvider.TryGetString(val, out string result, culture))
|
{
|
if (first)
|
first = false;
|
else
|
sb.Append(", ");
|
sb.Append(escapeString(result));
|
}
|
else
|
{
|
// Signal that the thing could not be converted.
|
return null;
|
}
|
}
|
|
return sb.ToString();
|
}
|
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// String convert for IResource types.
|
/// </summary>
|
internal class ResourceStringConvertProvider : IStringConvertProvider
|
{
|
IEnumerable<IResource> _allResources = null;
|
IEnumerable<IResource> allResources
|
{
|
get
|
{
|
if(_allResources == null)
|
{
|
var ilist = TypeData.FromType(typeof(IList));
|
var cmplists = TypeData.FromType(typeof(ComponentSettings)).DerivedTypes.Where(x => x.DescendsTo(ilist));
|
var reslists = cmplists.Where(x => x.ElementType.DescendsTo(typeof(IResource))).ToArray();
|
_allResources = reslists.SelectMany(x => ComponentSettings.GetCurrent(x.Type) as IEnumerable<IResource>);
|
}
|
return _allResources;
|
}
|
}
|
/// <summary> Finds a IResource based on strings. Only works on things loaded in Component Settings. </summary>
|
public object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture)
|
{
|
if (type.DescendsTo(typeof(IResource)) == false) return null;
|
if (type is TypeData)
|
return allResources.FirstOrDefault(x => x.Name == stringData && TypeData.GetTypeData(x).DescendsTo(type));
|
return null;
|
}
|
|
/// <summary> Turns a resource into a string. </summary>
|
public string GetString(object value, CultureInfo culture)
|
{
|
if (value is IResource)
|
return ((IResource)value).Name;
|
return null;
|
}
|
}
|
|
/// <summary> String convert provider for MacroString types.</summary>
|
internal class MacroStringConvertProvider : IStringConvertProvider
|
{
|
/// <summary> Creates a new MacroString, using the contextObject if its a ITestStep.</summary>
|
public object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture)
|
{
|
if (type.DescendsTo(typeof(MacroString)) == false) return null;
|
return new MacroString(contextObject as ITestStepParent) { Text = stringData };
|
}
|
/// <summary> Extracts the text component of a macro string. </summary>
|
public string GetString(object value, CultureInfo culture)
|
{
|
if (value is MacroString == false) return null;
|
return ((MacroString)value).Text;
|
}
|
}
|
|
/// <summary> String convert provider for SecureString </summary>
|
internal class SecureStringConvertProvider : IStringConvertProvider
|
{
|
/// <summary> Creates a new SecureString</summary>
|
public object FromString(string stringData, ITypeData targetType, object contextObject, CultureInfo culture)
|
{
|
if (targetType.IsA(typeof(SecureString)) == false) return null;
|
return stringData.ToSecureString();
|
}
|
/// <summary> Extracts the text component of a SecureString. </summary>
|
public string GetString(object obj, CultureInfo culture)
|
{
|
if (obj is SecureString == false) return null;
|
return ((SecureString)obj).ConvertToUnsecureString();
|
|
}
|
}
|
|
/// <summary> String convert provider for TestStep </summary>
|
internal class TestStepConvertProvider : IStringConvertProvider
|
{
|
internal static ITestStep GetStepFromContext(ITestStepParent context, Guid id)
|
{
|
ITestStepParent plan = context;
|
while (plan.Parent != null)
|
plan = plan.Parent;
|
return Utils.FlattenHeirarchy(plan.ChildTestSteps, x => x.ChildTestSteps)
|
.FirstOrDefault(x => x.Id == id);
|
}
|
/// <summary>
|
/// Gets a TestStep from a string value. This will be a step from the test plan context object.
|
/// </summary>
|
/// <param name="stringData"></param>
|
/// <param name="type"></param>
|
/// <param name="contextObject"></param>
|
/// <param name="culture"></param>
|
/// <returns></returns>
|
public object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture)
|
{
|
if (type.DescendsTo(typeof(ITestStep)) && contextObject is ITestStepParent parent)
|
{
|
if(Guid.TryParse(stringData, out Guid id))
|
{
|
return GetStepFromContext(parent, id);
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// Gets the ID of a step.
|
/// </summary>
|
/// <param name="value"></param>
|
/// <param name="culture"></param>
|
/// <returns></returns>
|
public string GetString(object value, CultureInfo culture)
|
{
|
return (value as ITestStep)?.Id.ToString();
|
}
|
}
|
|
/// <summary> Supports converting Inputs to a string and back. Requires the context to be an ITestStep.</summary>
|
internal class InputStringConvertProvider : IStringConvertProvider
|
{
|
/// <summary> Creates an Input from a string. contextObject must be an ITestStep.</summary>
|
/// <param name="stringData"></param>
|
/// <param name="type"></param>
|
/// <param name="contextObject"></param>
|
/// <param name="culture"></param>
|
/// <returns></returns>
|
public object FromString(string stringData, ITypeData type, object contextObject, CultureInfo culture)
|
{
|
if (!type.DescendsTo(typeof(IInput))) return null;
|
|
var s = stringData.Split(':');
|
var step = contextObject as ITestStep;
|
if (step == null) return null;
|
if (s.Length != 2) return null;
|
|
if (!Guid.TryParse(s[0], out var id))
|
return null;
|
var property = s[1];
|
|
var inp = (IInput)type.CreateInstance(Array.Empty<object>());
|
if (id == Guid.Empty)
|
return inp;
|
|
var step2 = TestStepConvertProvider.GetStepFromContext(step, id);
|
if (step2 == null) return null;
|
inp.Step = step2;
|
|
if (!string.IsNullOrWhiteSpace(property))
|
inp.Property = TypeData.GetTypeData(step2).GetMember(property);
|
|
return inp;
|
}
|
|
/// <summary> Turns an IInput into a string. </summary>
|
/// <param name="value"></param>
|
/// <param name="culture"></param>
|
/// <returns></returns>
|
public string GetString(object value, CultureInfo culture)
|
{
|
var val = value as IInput;
|
if (val == null) return null;
|
return $"{val.Step?.Id ?? Guid.Empty}:{val.Property?.Name ?? ""}";
|
}
|
}
|
|
/// <summary> Supports converting Inputs to a string and back.</summary>
|
internal class BoolConverter : IStringConvertProvider
|
{
|
/// <summary> Creates a bool from a string. </summary>
|
public object FromString(string stringData, ITypeData type, object ctx, CultureInfo culture)
|
{
|
if (type.IsA(typeof(bool)))
|
{
|
var sd = stringData.ToLower();
|
|
switch (sd)
|
{
|
case "true":
|
case "y":
|
case "yes":
|
return true;
|
case "false":
|
case "n":
|
case "no":
|
return false;
|
}
|
}
|
|
return null;
|
}
|
|
/// <summary> Gets the string representation of a bool. </summary>
|
public string GetString(object value, CultureInfo culture)
|
{
|
if (value is bool)
|
return value.ToString();
|
else
|
return null;
|
}
|
|
}
|
}
|
}
|
