private bool CanConvertArg(object value, IBindingType typeToConvertTo, CultureInfo bindingCulture) { if (typeToConvertTo.IsAssignableTo(value.GetType())) return true; return stepArgumentTypeConverter.CanConvert(value, typeToConvertTo, bindingCulture); }
public BindingMethod(IBindingType type, string name, IEnumerable<IBindingParameter> parameters, IBindingType returnType) { Type = type; Name = name; Parameters = parameters; ReturnType = returnType; }
protected override object Convert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeBindingType = (RuntimeBindingType)typeToConvertTo; var verticalTable = GetVerticalTable(table, runtimeBindingType); var values = GetValues(verticalTable); var objectInitializationData = GetObjectInitializationData(values.Keys, runtimeBindingType.Type); var bindingTypes = objectInitializationData.GetBindingTypes(); var convertedValues = values .Where(x => bindingTypes.ContainsKey(x.Key)) .ToDictionary( x => x.Key, x => stepArgumentTypeConverter.Convert(x.Value, bindingTypes[x.Key], cultureInfo)); var constructorParameters = objectInitializationData.Constructor.GetParameters() .Select(x => convertedValues[SanitizePropertyName(x.Name)]).ToArray(); var result = objectInitializationData.Constructor.Invoke(constructorParameters); foreach (var property in objectInitializationData.PropertiesToSet) { var value = convertedValues[SanitizePropertyName(property.Name)]; property.SetValue(result, value, null); } return result; }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (!(typeToConvertTo is RuntimeBindingType)) return false; try { Convert(value, typeToConvertTo, cultureInfo); return true; } catch (InvalidCastException) { return false; } catch (OverflowException) { return false; } catch (FormatException) { return false; } catch (ArgumentException) { return false; } }
protected override bool CanConvert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeBindingType = typeToConvertTo as RuntimeBindingType; if (runtimeBindingType == null) { return(false); } var verticalTable = GetVerticalTable(table, runtimeBindingType); if (verticalTable == null) { return(false); } var values = GetValues(verticalTable); var objectInitializationData = GetObjectInitializationData(values.Keys, runtimeBindingType.Type); if (objectInitializationData == null) { return(false); } var bindingTypes = objectInitializationData.GetBindingTypes(); return(values .Where(x => bindingTypes.ContainsKey(x.Key)) .All(x => stepArgumentTypeConverter.CanConvert(x.Value, bindingTypes[x.Key], cultureInfo))); }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (!(typeToConvertTo is RuntimeBindingType)) { return(false); } try { Convert(value, typeToConvertTo, cultureInfo); return(true); } catch (InvalidCastException) { return(false); } catch (OverflowException) { return(false); } catch (FormatException) { return(false); } catch (ArgumentException) { return(false); } }
protected override object Convert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeBindingType = (RuntimeBindingType)typeToConvertTo; var verticalTable = GetVerticalTable(table, runtimeBindingType); var values = GetValues(verticalTable); var objectInitializationData = GetObjectInitializationData(values.Keys, runtimeBindingType.Type); var bindingTypes = objectInitializationData.GetBindingTypes(); var convertedValues = values .Where(x => bindingTypes.ContainsKey(x.Key)) .ToDictionary( x => x.Key, x => stepArgumentTypeConverter.Convert(x.Value, bindingTypes[x.Key], cultureInfo)); var constructorParameters = objectInitializationData.Constructor.GetParameters() .Select(x => convertedValues[SanitizePropertyName(x.Name)]).ToArray(); var result = objectInitializationData.Constructor.Invoke(constructorParameters); foreach (var property in objectInitializationData.PropertiesToSet) { var value = convertedValues[SanitizePropertyName(property.Name)]; property.SetValue(result, value, null); } return(result); }
private object ConvertArg(object value, IBindingType typeToConvertTo) { Debug.Assert(value != null); Debug.Assert(typeToConvertTo != null); return(_stepArgumentTypeConverter.Convert(value, typeToConvertTo, FeatureContext.BindingCulture)); }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var table = value as Table; if (table == null) return false; return CanConvert(table, typeToConvertTo, cultureInfo); }
public BindingParameter(IBindingType type, string parameterName) { if (type == null) throw new ArgumentNullException("type"); if (parameterName == null) throw new ArgumentNullException("parameterName"); Type = type; ParameterName = parameterName; }
private static object ConvertSimple(IBindingType typeToConvertTo, object value, CultureInfo cultureInfo) { if (!(typeToConvertTo is RuntimeBindingType)) { throw new SpecFlowException("The StepArgumentTypeConverter can be used with runtime types only."); } return(ConvertSimple(((RuntimeBindingType)typeToConvertTo).Type, value, cultureInfo)); }
protected override bool CanConvert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var itemRuntimeType = GetItemRuntimeType(typeToConvertTo); if (itemRuntimeType == null || IsVerticalTable(table, itemRuntimeType)) return false; var rowFetcher = GetValidRowFetcherDelegate(table, itemRuntimeType, cultureInfo); return rowFetcher != null; }
private bool CanConvertArg(object value, IBindingType typeToConvertTo, CultureInfo bindingCulture) { if (typeToConvertTo.IsAssignableTo(value.GetType())) { return(true); } return(stepArgumentTypeConverter.CanConvert(value, typeToConvertTo, bindingCulture)); }
public static bool TypeEquals(this IBindingType type1, Type type2) { if (type1 is RuntimeBindingType) { return(((RuntimeBindingType)type1).Type == type2); } return(TypeEquals(type1, new RuntimeBindingType(type2))); }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var stepTransformation = GetMatchingStepTransformation(value, typeToConvertTo, true); if (stepTransformation == null) throw new SpecFlowException("The StepTransformationConverter cannot convert the specified value."); return DoTransform(stepTransformation, value, cultureInfo); }
protected virtual IStepArgumentTransformationBinding GetMatchingStepTransformation(object value, IBindingType typeToConvertTo, bool traceWarning) { var stepTransformations = bindingRegistry.GetStepTransformations().Where(t => CanConvert(t, value, typeToConvertTo)).ToArray(); if (stepTransformations.Length > 1 && traceWarning) { testTracer.TraceWarning(string.Format("Multiple step transformation matches to the input ({0}, target type: {1}). We use the first.", value, typeToConvertTo)); } return stepTransformations.Length > 0 ? stepTransformations[0] : null; }
public static bool TypeEquals(this IBindingType type1, IBindingType type2) { if (ReferenceEquals(type1, type2)) return true; if (type1 == null || type2 == null) return false; return type1.FullName == type2.FullName; }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var table = value as Table; if (table == null) { return(false); } return(CanConvert(table, typeToConvertTo, cultureInfo)); }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var stepTransformation = GetMatchingStepTransformation(value, typeToConvertTo, cultureInfo, true); if (stepTransformation == null) { throw new SpecFlowException("The StepTransformationConverter cannot convert the specified value."); } return(DoTransform(stepTransformation, value, cultureInfo)); }
public BindingMethod(IBindingType type, string name, IEnumerable<IBindingParameter> parameters, IBindingType returnType) { if (type == null) throw new ArgumentNullException("type"); if (name == null) throw new ArgumentNullException("name"); if (parameters == null) throw new ArgumentNullException("parameters"); Type = type; Name = name; Parameters = parameters; ReturnType = returnType; }
private bool CanConvertArg(object value, IBindingType typeToConvertTo) { Debug.Assert(value != null); Debug.Assert(typeToConvertTo != null); if (typeToConvertTo.IsAssignableTo(value.GetType())) return true; //TODO: proper param matching //return stepArgumentTypeConverter.CanConvert(value, typeToConvertTo, FeatureContext.Current.BindingCulture); return false; }
private object ConvertArg(object value, IBindingType typeToConvertTo) { Debug.Assert(value != null); Debug.Assert(typeToConvertTo != null); if (typeToConvertTo.IsAssignableTo(value.GetType())) { return(value); } return(stepArgumentTypeConverter.Convert(value, typeToConvertTo, FeatureContext.BindingCulture)); }
private bool CanConvert(IStepArgumentTransformationBinding stepTransformationBinding, object value, IBindingType typeToConvertTo) { if (!stepTransformationBinding.Method.ReturnType.TypeEquals(typeToConvertTo)) return false; if (stepTransformationBinding.Regex != null) { return value is string && stepTransformationBinding.Regex.IsMatch((string)value); } return stepTransformationBinding.Method.Parameters.Count() == 1; }
protected override bool CanConvert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var itemRuntimeType = GetItemRuntimeType(typeToConvertTo); if (itemRuntimeType == null || IsVerticalTable(table, itemRuntimeType)) { return(false); } var rowFetcher = GetValidRowFetcherDelegate(table, itemRuntimeType, cultureInfo); return(rowFetcher != null); }
public static bool TypeEquals(this IBindingType type1, IBindingType type2) { if (ReferenceEquals(type1, type2)) return true; if (type1 == null || type2 == null) return false; if (type1 is RuntimeBindingType && type2 is RuntimeBindingType) return ((RuntimeBindingType)type1).Type.Equals(((RuntimeBindingType)type2).Type); return type1.FullName == type2.FullName; }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (value == null) throw new ArgumentNullException("value"); if (typeToConvertTo == value.GetType()) return true; var stepTransformation = GetMatchingStepTransformation(value, typeToConvertTo, false); if (stepTransformation != null) return true; return CanConvertSimple(typeToConvertTo, value, cultureInfo); }
protected override object Convert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var itemRuntimeType = GetItemRuntimeType(typeToConvertTo); var rowFetcher = GetValidRowFetcherDelegate(table, itemRuntimeType, cultureInfo); var result = Array.CreateInstance(itemRuntimeType.Type, table.RowCount); for (int i = 0; i < result.Length; i++) { var item = stepArgumentTypeConverter.Convert(rowFetcher(i), itemRuntimeType, cultureInfo); result.SetValue(item, i); } return result; }
public static bool TypeEquals(this IBindingType type1, IBindingType type2) { if (ReferenceEquals(type1, type2)) { return(true); } if (type1 == null || type2 == null) { return(false); } return(type1.FullName == type2.FullName); }
public static bool IsAssignableFrom(this Type baseType, IBindingType type) { if (type is IPolymorphicBindingType polymorphicBindingType) { return(polymorphicBindingType.IsAssignableTo(new RuntimeBindingType(baseType))); } if (type.FullName == baseType.FullName) { return(true); } return(false); }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (!(typeToConvertTo is RuntimeBindingType)) { Type systemType = Type.GetType(typeToConvertTo.FullName, false); if (systemType == null) { return(false); } typeToConvertTo = new RuntimeBindingType(systemType); } return(StepArgumentTypeConverter.CanConvertSimple(typeToConvertTo, value, cultureInfo)); }
private bool CanConvertArg(object value, IBindingType typeToConvertTo) { Debug.Assert(value != null); Debug.Assert(typeToConvertTo != null); if (typeToConvertTo.IsAssignableTo(value.GetType())) { return(true); } //TODO: proper param matching //return stepArgumentTypeConverter.CanConvert(value, typeToConvertTo, FeatureContext.Current.BindingCulture); return(false); }
public BindingParameter(IBindingType type, string parameterName) { if (type == null) { throw new ArgumentNullException("type"); } if (parameterName == null) { throw new ArgumentNullException("parameterName"); } Type = type; ParameterName = parameterName; }
protected override object Convert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var itemRuntimeType = GetItemRuntimeType(typeToConvertTo); var rowFetcher = GetValidRowFetcherDelegate(table, itemRuntimeType, cultureInfo); var result = Array.CreateInstance(itemRuntimeType.Type, table.RowCount); for (int i = 0; i < result.Length; i++) { var item = stepArgumentTypeConverter.Convert(rowFetcher(i), itemRuntimeType, cultureInfo); result.SetValue(item, i); } return(result); }
private Func<int, object> GetValidRowFetcherDelegate(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (table.RowCount == 0) return x => null; var pivotTable = new PivotTable(table); if (stepArgumentTypeConverter.CanConvert(pivotTable.GetInstanceTable(0), typeToConvertTo, cultureInfo)) return x => pivotTable.GetInstanceTable(x); if (table.Header.Count == 1 && stepArgumentTypeConverter.CanConvert(table.Rows[0][0], typeToConvertTo, cultureInfo)) return x => table.Rows[x][0]; return null; }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeType = (RuntimeBindingType)typeToConvertTo; if (runtimeType.Type.IsEnum && value is string) return Enum.Parse(runtimeType.Type, ((string)value).Replace(" ", ""), true); if (runtimeType.Type == typeof(Guid?) && string.IsNullOrEmpty(value as string)) return null; if (runtimeType.Type == typeof(Guid) || runtimeType.Type == typeof(Guid?)) return new GuidValueRetriever().GetValue(value as string); return System.Convert.ChangeType(value, runtimeType.Type, cultureInfo); }
private RuntimeBindingType GetItemRuntimeType(IBindingType typeToConvertTo) { var runtimeType = typeToConvertTo as RuntimeBindingType; if (runtimeType == null) return null; var type = runtimeType.Type; if (type.IsArray && type.GetArrayRank() == 1) return new RuntimeBindingType(type.GetElementType()); if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>)) return new RuntimeBindingType(type.GetGenericArguments()[0]); return null; }
public CucumberExpressionParameterType(string name, IBindingType targetType, IEnumerable <ICucumberExpressionParameterTypeTransformation> transformations) { Name = name; TargetType = targetType; Transformations = transformations.ToArray(); var regexStrings = Transformations.Select(tr => tr.Regex).Distinct().ToArray(); if (regexStrings.Length > 1 && regexStrings.Contains(MatchAllRegex)) { regexStrings = new[] { MatchAllRegex } } ; RegexStrings = regexStrings; } }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeType = typeToConvertTo as RuntimeBindingType; if (runtimeType == null) { return(false); } var targetType = runtimeType.Type; if (value == null) { return(!targetType.IsValueType); } if (!targetType.IsEnum || targetType != typeof(Guid) || targetType != typeof(Guid?)) { var convertible = value as IConvertible; if (convertible == null) { return(value.GetType() == targetType); } } try { Convert(value, typeToConvertTo, cultureInfo); return(true); } catch (InvalidCastException) { return(false); } catch (OverflowException) { return(false); } catch (FormatException) { return(false); } catch (ArgumentException) { return(false); } }
public static bool TypeEquals(this IBindingType type1, IBindingType type2) { if (ReferenceEquals(type1, type2)) { return(true); } if (type1 == null || type2 == null) { return(false); } if (type1 is RuntimeBindingType && type2 is RuntimeBindingType) { return(((RuntimeBindingType)type1).Type == ((RuntimeBindingType)type2).Type); } return(type1.FullName == type2.FullName); }
public static bool IsAssignableTo(this IBindingType baseType, Type type) { if (baseType is RuntimeBindingType) { return(type.IsAssignableFrom(((RuntimeBindingType)baseType).Type)); } if (type.FullName == baseType.FullName) { return(true); } if (type.BaseType != null && IsAssignableTo(baseType, type.BaseType)) { return(true); } return(type.GetInterfaces().Any(_if => IsAssignableTo(baseType, _if))); }
protected override bool CanConvert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeBindingType = typeToConvertTo as RuntimeBindingType; if (runtimeBindingType == null) return false; var verticalTable = GetVerticalTable(table, runtimeBindingType); if (verticalTable == null) return false; var values = GetValues(verticalTable); var objectInitializationData = GetObjectInitializationData(values.Keys, runtimeBindingType.Type); if (objectInitializationData == null) return false; var bindingTypes = objectInitializationData.GetBindingTypes(); return values .Where(x => bindingTypes.ContainsKey(x.Key)) .All(x => stepArgumentTypeConverter.CanConvert(x.Value, bindingTypes[x.Key], cultureInfo)); }
public BindingMethod(IBindingType type, string name, IEnumerable <IBindingParameter> parameters, IBindingType returnType) { if (type == null) { throw new ArgumentNullException("type"); } if (name == null) { throw new ArgumentNullException("name"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } Type = type; Name = name; Parameters = parameters; ReturnType = returnType; }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (value == null) { throw new ArgumentNullException("value"); } if (typeToConvertTo == value.GetType()) { return(true); } var stepTransformation = GetMatchingStepTransformation(value, typeToConvertTo, false); if (stepTransformation != null) { return(true); } return(CanConvertSimple(typeToConvertTo, value, cultureInfo)); }
public async Task <object> ConvertAsync(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (value == null) { throw new ArgumentNullException(nameof(value)); } var stepTransformation = GetMatchingStepTransformation(value, typeToConvertTo, true); if (stepTransformation != null) { return(await DoTransformAsync(stepTransformation, value, cultureInfo)); } if (typeToConvertTo is RuntimeBindingType convertToType && convertToType.Type.IsAssignableFrom(value.GetType())) { return(value); } return(ConvertSimple(typeToConvertTo, value, cultureInfo)); }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var runtimeType = (RuntimeBindingType)typeToConvertTo; if (runtimeType.Type.IsEnum && value is string) { return(Enum.Parse(runtimeType.Type, ((string)value).Replace(" ", ""), true)); } if (runtimeType.Type == typeof(Guid?) && string.IsNullOrEmpty(value as string)) { return(null); } if (runtimeType.Type == typeof(Guid) || runtimeType.Type == typeof(Guid?)) { return(new GuidValueRetriever().GetValue(value as string)); } return(System.Convert.ChangeType(value, runtimeType.Type, cultureInfo)); }
private Func <int, object> GetValidRowFetcherDelegate(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (table.RowCount == 0) { return(x => null); } var pivotTable = new PivotTable(table); if (stepArgumentTypeConverter.CanConvert(pivotTable.GetInstanceTable(0), typeToConvertTo, cultureInfo)) { return(x => pivotTable.GetInstanceTable(x)); } if (table.Header.Count == 1 && stepArgumentTypeConverter.CanConvert(table.Rows[0][0], typeToConvertTo, cultureInfo)) { return(x => table.Rows[x][0]); } return(null); }
private RuntimeBindingType GetItemRuntimeType(IBindingType typeToConvertTo) { var runtimeType = typeToConvertTo as RuntimeBindingType; if (runtimeType == null) { return(null); } var type = runtimeType.Type; if (type.IsArray && type.GetArrayRank() == 1) { return(new RuntimeBindingType(type.GetElementType())); } if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { return(new RuntimeBindingType(type.GetGenericArguments()[0])); } return(null); }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (value == null) { throw new ArgumentNullException("value"); } var stepTransformation = GetMatchingStepTransformation(value, typeToConvertTo, false); if (stepTransformation != null) { return(true); } var convertToType = typeToConvertTo as RuntimeBindingType; if (convertToType != null && convertToType.Type.IsAssignableFrom(value.GetType())) { return(true); } return(CanConvertSimple(typeToConvertTo, value, cultureInfo)); }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (!(typeToConvertTo is RuntimeBindingType)) { try { // in some special cases, Type.GetType throws exception // one of such case, if a Dictionary<string,string> step parameter is specified, see issue #340 Type systemType = Type.GetType(typeToConvertTo.FullName, false); if (systemType == null) { return(false); } typeToConvertTo = new RuntimeBindingType(systemType); } catch (Exception ex) { Debug.WriteLine(ex); return(false); } } return(StepArgumentTypeConverter.CanConvertSimple(typeToConvertTo, value, cultureInfo)); }
public static bool CanConvertSimple(IBindingType typeToConvertTo, object value, CultureInfo cultureInfo) { try { ConvertSimple(typeToConvertTo, value, cultureInfo); return true; } catch (InvalidCastException) { return false; } catch (OverflowException) { return false; } catch (FormatException) { return false; } catch (ArgumentException) { return false; } }
public static bool CanConvertSimple(IBindingType typeToConvertTo, object value, CultureInfo cultureInfo) { try { ConvertSimple(typeToConvertTo, value, cultureInfo); return(true); } catch (InvalidCastException) { return(false); } catch (OverflowException) { return(false); } catch (FormatException) { return(false); } catch (ArgumentException) { return(false); } }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { throw new NotSupportedException(); }
protected abstract object Convert(Table table, IBindingType typeToConvertTo, CultureInfo cultureInfo);
private IStepArgumentTypeConverter GetConverter(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { return converters.FirstOrDefault(x => x.CanConvert(value, typeToConvertTo, cultureInfo)); }
private bool CanConvert(IStepArgumentTransformationBinding stepTransformationBinding, object value, IBindingType typeToConvertTo) { if (!stepTransformationBinding.Method.ReturnType.TypeEquals(typeToConvertTo)) return false; if (stepTransformationBinding.Regex != null && value is string) return stepTransformationBinding.Regex.IsMatch((string) value); return true; }
public BindingParameter(IBindingType type, string parameterName) { Type = type; ParameterName = parameterName; }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { return GetConverter(value, typeToConvertTo, cultureInfo) != null; }
public bool CanConvert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { if (!(typeToConvertTo is RuntimeBindingType)) { Type systemType = Type.GetType(typeToConvertTo.FullName, false); if (systemType == null) return false; typeToConvertTo = new RuntimeBindingType(systemType); } return StepArgumentTypeConverter.CanConvertSimple(typeToConvertTo, value, cultureInfo); }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { return Convert((Table)value, typeToConvertTo, cultureInfo); }
public object Convert(object value, IBindingType typeToConvertTo, CultureInfo cultureInfo) { var converter = GetConverter(value, typeToConvertTo, cultureInfo); return converter.Convert(value, typeToConvertTo, cultureInfo); }