public void CellReader_SetValid_GetReturnsExpected(ISingleCellValueReader value)
{
var reader = new ColumnNameValueReader("Column");
var map = new SubOneToOneMap <int>(reader)
{
CellReader = value
};
Assert.Same(value, map.CellReader);
// Set same.
map.CellReader = value;
Assert.Same(value, map.CellReader);
}
internal static bool TryCreatePrimitiveMap <T>(MemberInfo member, FallbackStrategy emptyValueStrategy, out OneToOneMap <T> map)
{
if (!TryGetWellKnownMap(typeof(T), emptyValueStrategy, out ICellValueMapper mapper, out IFallbackItem emptyFallback, out IFallbackItem invalidFallback))
{
map = null;
return(false);
}
ISingleCellValueReader defaultReader = GetDefaultSingleCellValueReader(member);
map = new OneToOneMap <T>(defaultReader)
.WithCellValueMappers(mapper)
.WithEmptyFallbackItem(emptyFallback)
.WithInvalidFallbackItem(invalidFallback);
return(true);
}
/// <summary>
/// Creates a map for a property or field given a MemberExpression reading the property or field.
/// This is used for map enums.
/// </summary>
/// <typeparam name="TProperty">The enum type of the property or field to map.</typeparam>
/// <param name="expression">A MemberExpression reading the property or field.</param>
/// <param name="ignoreCase">A flag indicating whether enum parsing is case insensitive.</param>
/// <returns>The map for the given property or field.</returns>
public OneToOneMap <TProperty> Map <TProperty>(Expression <Func <T, TProperty> > expression, bool ignoreCase) where TProperty : struct
{
if (!typeof(TProperty).GetTypeInfo().IsEnum)
{
throw new ArgumentException($"The type ${typeof(TProperty)} must be an Enum.", nameof(TProperty));
}
MemberExpression memberExpression = GetMemberExpression(expression);
var mapper = new EnumMapper(typeof(TProperty), ignoreCase);
ISingleCellValueReader defaultReader = AutoMapper.GetDefaultSingleCellValueReader(memberExpression.Member);
var map = new OneToOneMap <TProperty>(defaultReader)
.WithCellValueMappers(mapper)
.WithThrowingEmptyFallback()
.WithThrowingInvalidFallback();
AddMap(new ExcelPropertyMap <TProperty>(memberExpression.Member, map), expression);
return(map);
}
public SubSplitCellValueReader(ISingleCellValueReader cellReader) : base(cellReader)
{
}
/// <summary>
/// Sets the reader of the property map to use a custom cell value reader.
/// </summary>
/// <typeparam name="T">The type of the property map.</typeparam>
/// <param name="propertyMap">The property map to use.</param>
/// <param name="reader">The custom reader to use.</param>
/// <returns>The property map on which this method was invoked.</returns>
public static OneToOneMap <T> WithReader <T>(this OneToOneMap <T> propertyMap, ISingleCellValueReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
propertyMap.CellReader = reader;
return(propertyMap);
}
public OneToOneMap(ISingleCellValueReader reader)
{
CellReader = reader ?? throw new ArgumentNullException(nameof(reader));
}
public SubOneToOneMap(ISingleCellValueReader reader) : base(reader)
{
}
