public void RemoveConverter_ConverterIsNull_ConverterCountIsZero()
{
ICustomConverter <Int16> nullConverter = null;
nullConverter.RemoveConverter();
Assert.That(this.GetConverterCount(), Is.Zero);
}
public void Convert_Test_When_Array_Has_Elements_And_Converter_Is_Null_And_Elements_Are_Type_Compatible_And_Value_Convertible()
{
int[] array = new int[] { 1, 2, 3 };
ICustomConverter <int, string> converter = null;
var result = ArrayHelper.ArrayHelper.Convert(array, converter);
CollectionAssert.AreEqual(new[] { "1", "2", "3" }, result);
}
public void Convert_Test_When_Array_Is_Null_And_Converter_Is_Null()
{
int[] array = null;
ICustomConverter <int, string> converter = null;
var result = ArrayHelper.ArrayHelper.Convert(array, converter);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Length);
}
public void Convert_Test_When_Array_Has_Elements_And_Converter_Is_Null_And_Elements_Are_Not_Type_Compatible()
{
string[] array = new string[] { "1", "2", "3" };
ICustomConverter <string, int> converter = null;
var result = ArrayHelper.ArrayHelper.Convert(array, converter);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Length);
}
public Convertion(FieldInfo _fieldInfo)
{
fieldInfo = _fieldInfo;
var attr = _fieldInfo.GetCustomAttributes(typeof(CSVTitleAttribute), true)[0] as CSVTitleAttribute;
orderIndex = attr.order;
converter = attr.Convert;
if (converter == null)
{
method = SelectConvertion(_fieldInfo);
}
}
public static void RemoveConverter <TTarget>(this ICustomConverter <TTarget> converter)
{
if (converter == null)
{
return;
}
String qualifier = CustomConverterExtension.GetQualifier <TTarget>();
if (CustomConverterExtension.converters.ContainsKey(qualifier))
{
CustomConverterExtension.converters.Remove(qualifier);
}
}
public static void AddConverter <TTarget>(this ICustomConverter <TTarget> converter)
{
if (converter == null)
{
return;
}
String qualifier = CustomConverterExtension.GetQualifier <TTarget>();
if (!CustomConverterExtension.converters.ContainsKey(qualifier))
{
CustomConverterExtension.converters.Add(qualifier, null);
}
CustomConverterExtension.converters[qualifier] = converter;
}
private static IEnumerable<T> MatchesDynamic<T>(Regex regex, string input, ICustomConverter<T> converter = null)
where T : class, new()
{
string[] groupNames = regex.GetGroupNames();
foreach (Match m in regex.Matches(input).OfType<Match>().Where(f => f.Success))
{
dynamic itm = new DynamicResult(m, groupNames);
for (int i = 1; i < m.Groups.Count; ++i)
{
string groupName = regex.GroupNameFromNumber(i);
if (converter != null)
converter.Convert(groupName, m.Groups[i], itm);
}
yield return itm;
}
}
public static ArrayConversionResult <T, U> Convert <T, U>(T[] array, ICustomConverter <T, U> converter)
{
if ((array == null) || (array.Length == 0))
{
return(ArrayConversionResult <T, U> .Empty());
}
if (converter == null)
{
converter = new CustomConverter <T, U>();
}
if (!converter.CanConvertBetweenTypes())
{
return(ArrayConversionResult <T, U> .Empty());
}
var convertedValues = new List <U>();
var failConvertValues = new List <T>();
for (int i = 0; i < array.Length; i++)
{
T item = array[i];
U convertedItem;
if (converter.TryConvertValue(item, out convertedItem))
{
convertedValues.Add(convertedItem);
}
else
{
failConvertValues.Add(item);
}
}
var nonConvertibleValues = failConvertValues.ToArray();
var effectivelyConvertedValues = convertedValues.ToArray();
return(new ArrayConversionResult <T, U>(effectivelyConvertedValues, nonConvertibleValues));
}
public static U[] Convert <T, U>(T[] array, ICustomConverter <T, U> converter, out T[] nonConvertibleValues)
{
nonConvertibleValues = new T[0];
if ((array == null) || (array.Length == 0))
{
return(new U[0]);
}
if (converter == null)
{
converter = new CustomConverter <T, U>();
}
if (!converter.CanConvertBetweenTypes())
{
return(new U[0]);
}
var convertedValues = new List <U>();
var failConvertValues = new List <T>();
for (int i = 0; i < array.Length; i++)
{
T item = array[i];
U convertedItem;
if (converter.TryConvertValue(item, out convertedItem))
{
convertedValues.Add(convertedItem);
}
else
{
failConvertValues.Add(item);
}
}
nonConvertibleValues = failConvertValues.ToArray();
return(convertedValues.ToArray());
}
public static U[] Convert <T, U>(T[] array, ICustomConverter <T, U> converter)
{
T[] nonConvertibleValues;
return(ArrayHelper.Convert <T, U>(array, converter, out nonConvertibleValues));
}
