public ChoFieldValueTrimOption GetFieldValueTrimOption(Type fieldType, ChoFieldValueTrimOption?recordLevelFieldValueTrimOption)
{
ChoFieldValueTrimOption?fieldValueTrimOption = FieldValueTrimOption;
if (fieldValueTrimOption != null)
{
return(fieldValueTrimOption.Value);
}
if (recordLevelFieldValueTrimOption != null)
{
return(recordLevelFieldValueTrimOption.Value);
}
if (fieldType == typeof(int) ||
fieldType == typeof(uint) ||
fieldType == typeof(long) ||
fieldType == typeof(ulong) ||
fieldType == typeof(short) ||
fieldType == typeof(ushort) ||
fieldType == typeof(byte) ||
fieldType == typeof(sbyte) ||
fieldType == typeof(float) ||
fieldType == typeof(double) ||
fieldType == typeof(decimal) ||
fieldType == typeof(Single)
)
{
return(ChoFieldValueTrimOption.TrimStart);
}
else
{
return(ChoFieldValueTrimOption.TrimEnd);
}
}
public ChoFieldValueTrimOption GetFieldValueTrimOptionForRead(Type fieldType, ChoFieldValueTrimOption?recordLevelFieldValueTrimOption)
{
ChoFieldValueTrimOption?fieldValueTrimOption = FieldValueTrimOption;
if (fieldValueTrimOption != null)
{
return(fieldValueTrimOption.Value);
}
else
{
return(recordLevelFieldValueTrimOption != null ? recordLevelFieldValueTrimOption.Value : ChoFieldValueTrimOption.Trim);
}
}
public ChoFieldValueTrimOption GetFieldValueTrimOptionForRead(Type fieldType)
{
ChoFieldValueTrimOption?fieldValueTrimOption = FieldValueTrimOption;
if (fieldValueTrimOption != null)
{
return(fieldValueTrimOption.Value);
}
else
{
return(ChoFieldValueTrimOption.Trim);
}
}
private string NormalizeFieldValue(string fieldName, string fieldValue, int?size, bool truncate, bool?quoteField,
ChoFieldValueJustification fieldValueJustification, char fillChar, bool isHeader = false, string nullValue = null,
ChoFieldValueTrimOption?fieldValueTrimOption = null)
{
string lFieldValue = fieldValue;
bool retValue = false;
if (retValue)
{
return(lFieldValue);
}
if (fieldValue.IsNull())
{
fieldValue = String.Empty;
}
bool quoteValue = quoteField != null ? quoteField.Value : false;
if (quoteField == null || !quoteField.Value)
{
if (fieldValue.StartsWith(Configuration.QuoteChar.ToString()) && fieldValue.EndsWith(Configuration.QuoteChar.ToString()))
{
}
else
{
if (fieldValue.Contains(Configuration.EOLDelimiter))
{
if (isHeader)
{
throw new ChoParserException("Field header '{0}' value contains EOL delimiter character.".FormatString(fieldName));
}
else
{
quoteValue = true;
}
}
}
}
else
{
if (fieldValue.StartsWith(Configuration.QuoteChar.ToString()) && fieldValue.EndsWith(Configuration.QuoteChar.ToString()))
{
}
else
{
quoteValue = true;
}
}
if (fieldValue.IsNullOrEmpty())
{
if (nullValue != null)
{
fieldValue = nullValue;
}
}
if (size != null)
{
if (quoteValue)
{
size = size.Value - 2;
}
if (size <= 0)
{
return(String.Empty);
}
if (fieldValue.Length < size.Value)
{
if (fillChar != ChoCharEx.NUL)
{
if (fieldValueJustification == ChoFieldValueJustification.Right)
{
fieldValue = fieldValue.PadLeft(size.Value, fillChar);
}
else if (fieldValueJustification == ChoFieldValueJustification.Left)
{
fieldValue = fieldValue.PadRight(size.Value, fillChar);
}
}
}
else if (fieldValue.Length > size.Value)
{
if (truncate)
{
if (fieldValueTrimOption != null)
{
if (fieldValueTrimOption == ChoFieldValueTrimOption.TrimStart)
{
fieldValue = fieldValue.Right(size.Value);
}
else
{
fieldValue = fieldValue.Substring(0, size.Value);
}
}
else
{
fieldValue = fieldValue.Substring(0, size.Value);
}
}
else
{
if (isHeader)
{
throw new ApplicationException("Field header value length overflowed for '{0}' member [Expected: {1}, Actual: {2}].".FormatString(fieldName, size, fieldValue.Length));
}
else
{
throw new ApplicationException("Field value length overflowed for '{0}' member [Expected: {1}, Actual: {2}].".FormatString(fieldName, size, fieldValue.Length));
}
}
}
}
if (quoteValue)
{
fieldValue = "{1}{0}{1}".FormatString(fieldValue, Configuration.QuoteChar);
}
return(fieldValue);
}
public ChoFixedLengthReader <T> WithField(string name, int startIndex, int size, Type fieldType = null, bool?quoteField = null, ChoFieldValueTrimOption?fieldValueTrimOption = null,
string fieldName = null, Func <object, object> valueConverter = null)
{
if (!name.IsNullOrEmpty())
{
if (!_clearFields)
{
Configuration.FixedLengthRecordFieldConfigurations.Clear();
_clearFields = true;
}
if (fieldName.IsNullOrWhiteSpace())
{
fieldName = name;
}
Configuration.FixedLengthRecordFieldConfigurations.Add(new ChoFixedLengthRecordFieldConfiguration(name.NTrim(), startIndex, size)
{
FieldType = fieldType,
QuoteField = quoteField, FieldValueTrimOption = fieldValueTrimOption, FieldName = fieldName.NTrim(), ValueConverter = valueConverter
});
}
return(this);
}
private ChoFixedLengthReader <T> WithField(string name, int startIndex, int size, Type fieldType = null, bool?quoteField = null, ChoFieldValueTrimOption?fieldValueTrimOption = null,
string fieldName = null, Func <object, object> valueConverter = null,
Func <dynamic, object> valueSelector = null,
object defaultValue = null, object fallbackValue = null, string altFieldNames = null,
string fullyQualifiedMemberName = null, string formatText = null, string nullValue = null, Func <object> expr = null)
{
if (!name.IsNullOrEmpty())
{
if (!_clearFields)
{
ClearFields();
Configuration.MapRecordFields(Configuration.RecordType);
}
if (fieldName.IsNullOrWhiteSpace())
{
fieldName = name;
}
string fnTrim = name.NTrim();
ChoFixedLengthRecordFieldConfiguration fc = null;
PropertyDescriptor pd = null;
if (Configuration.FixedLengthRecordFieldConfigurations.Any(o => o.Name == fnTrim))
{
fc = Configuration.FixedLengthRecordFieldConfigurations.Where(o => o.Name == fnTrim).First();
Configuration.FixedLengthRecordFieldConfigurations.Remove(fc);
}
else
{
pd = ChoTypeDescriptor.GetNestedProperty(typeof(T), fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName);
}
var nfc = new ChoFixedLengthRecordFieldConfiguration(fnTrim, startIndex, size)
{
FieldType = fieldType,
QuoteField = quoteField,
FieldValueTrimOption = fieldValueTrimOption,
FieldName = fieldName,
ValueConverter = valueConverter,
ValueSelector = valueSelector,
DefaultValue = defaultValue,
FallbackValue = fallbackValue,
AltFieldNames = altFieldNames,
FormatText = formatText,
NullValue = nullValue,
Expr = expr,
};
if (fullyQualifiedMemberName.IsNullOrWhiteSpace())
{
nfc.PropertyDescriptor = fc != null ? fc.PropertyDescriptor : pd;
nfc.DeclaringMember = fc != null ? fc.DeclaringMember : fullyQualifiedMemberName;
}
else
{
pd = ChoTypeDescriptor.GetNestedProperty(typeof(T), fullyQualifiedMemberName);
nfc.PropertyDescriptor = pd;
nfc.DeclaringMember = fullyQualifiedMemberName;
}
if (pd != null)
{
if (nfc.FieldType == null)
{
nfc.FieldType = pd.PropertyType;
}
}
Configuration.FixedLengthRecordFieldConfigurations.Add(nfc);
}
return(this);
}
public ChoFixedLengthReader <T> WithField(string name, int startIndex, int size, Type fieldType = null, bool?quoteField = null, ChoFieldValueTrimOption?fieldValueTrimOption = null,
string fieldName = null, Func <object, object> valueConverter = null,
Func <dynamic, object> valueSelector = null,
object defaultValue = null, object fallbackValue = null, string altFieldNames = null, string formatText = null,
string nullValue = null, Func <object> expr = null)
{
return(WithField(name, startIndex, size, fieldType, quoteField, fieldValueTrimOption,
fieldName, valueConverter, valueSelector, defaultValue, fallbackValue, altFieldNames, null, formatText, nullValue, expr));
}
public ChoFixedLengthReader <T> WithField <TField>(Expression <Func <T, TField> > field, int startIndex, int size, bool?quoteField = null, ChoFieldValueTrimOption?fieldValueTrimOption = null,
string fieldName = null, Func <object, object> valueConverter = null,
Func <dynamic, object> valueSelector = null,
object defaultValue = null, object fallbackValue = null, string altFieldNames = null,
string formatText = null,
string nullValue = null, Func <object> expr = null)
{
if (field == null)
{
return(this);
}
return(WithField(field.GetMemberName(), startIndex, size, field.GetPropertyType(), quoteField, fieldValueTrimOption,
fieldName, valueConverter, valueSelector, defaultValue, fallbackValue, altFieldNames, field.GetFullyQualifiedMemberName(),
formatText, nullValue, expr));
}
public ChoCSVRecordFieldConfigurationMap TrimOption(ChoFieldValueTrimOption?value)
{
_config.FieldValueTrimOption = value;
return(this);
}
public ChoFixedLengthReader <T> WithField(string name, int startIndex, int size, bool?quoteField = null, ChoFieldValueTrimOption?fieldValueTrimOption = null, string fieldName = null)
{
return(WithField(name, startIndex, size, null, quoteField, fieldValueTrimOption, fieldName));
}
private string NormalizeFieldValue(string fieldName, string fieldValue, int?size, bool truncate, bool?quoteField,
ChoFieldValueJustification fieldValueJustification, char fillChar, bool isHeader = false, ChoFieldValueTrimOption?fieldValueTrimOption = null)
{
string lFieldValue = fieldValue;
bool retValue = false;
if (retValue)
{
return(lFieldValue);
}
if (fieldValue.IsNull())
{
fieldValue = String.Empty;
}
if (quoteField == null || !quoteField.Value)
{
if (fieldValue.StartsWith("\"") && fieldValue.EndsWith("\""))
{
}
else
{
if (!EOLDelimiter.IsNullOrEmpty() && fieldValue.Contains(EOLDelimiter))
{
if (isHeader)
{
throw new ChoParserException("Field header '{0}' value contains EOL delimiter character.".FormatString(fieldName));
}
else
{
fieldValue = "\"{0}\"".FormatString(fieldValue);
}
}
}
}
else
{
if (fieldValue.StartsWith("\"") && fieldValue.EndsWith("\""))
{
}
else
{
fieldValue = "\"{0}\"".FormatString(fieldValue);
}
}
if (size != null)
{
if (fieldValue.Length < size.Value)
{
if (fillChar != ChoCharEx.NUL)
{
if (fieldValueJustification == ChoFieldValueJustification.Right)
{
fieldValue = fieldValue.PadLeft(size.Value, fillChar);
}
else if (fieldValueJustification == ChoFieldValueJustification.Left)
{
fieldValue = fieldValue.PadRight(size.Value, fillChar);
}
}
}
else if (fieldValue.Length > size.Value)
{
if (truncate)
{
if (fieldValueTrimOption != null)
{
if (fieldValueTrimOption == ChoFieldValueTrimOption.TrimStart)
{
fieldValue = fieldValue.Right(size.Value);
}
else
{
fieldValue = fieldValue.Substring(0, size.Value);
}
}
else
{
fieldValue = fieldValue.Substring(0, size.Value);
}
}
else
{
if (isHeader)
{
throw new ApplicationException("Field header value length overflowed for '{0}' member [Expected: {1}, Actual: {2}].".FormatString(fieldName, size, fieldValue.Length));
}
else
{
throw new ApplicationException("Field value length overflowed for '{0}' member [Expected: {1}, Actual: {2}].".FormatString(fieldName, size, fieldValue.Length));
}
}
}
}
//return fieldValue.StartsWith("<![CDATA[") ? fieldValue : System.Net.WebUtility.HtmlEncode(fieldValue);
//escape quotes
if (fieldValue.Contains('"'))
{
fieldValue = fieldValue.Replace(@"""", @"\""");
}
return(fieldValue);
}
private string NormalizeFieldValue(string fieldName, string fieldValue, int?size, bool truncate, bool?quoteField,
ChoFieldValueJustification fieldValueJustification, char fillChar, bool isHeader = false, string nullValue = null,
ChoFieldValueTrimOption?fieldValueTrimOption = null, ChoCSVRecordFieldConfiguration fieldConfig = null)
{
string lFieldValue = fieldValue;
bool retValue = false;
quoteValue = quoteField != null ? quoteField.Value : false;
if (retValue)
{
return(lFieldValue);
}
if (fieldValue.IsNull())
{
fieldValue = String.Empty;
}
if (fieldValue.StartsWith(Configuration.QuoteChar.ToString()) && fieldValue.EndsWith(Configuration.QuoteChar.ToString()))
{
}
else
{
if (quoteField == null)
{
if (searchStrings == null)
{
searchStrings = (Configuration.QuoteChar.ToString() + Configuration.Delimiter + Configuration.EOLDelimiter).ToArray();
}
if (fieldValue.IndexOfAny(searchStrings) >= 0)
{
//******** ORDER IMPORTANT *********
//Fields that contain double quote characters must be surounded by double-quotes, and the embedded double-quotes must each be represented by a pair of consecutive double quotes.
if (fieldValue.IndexOf(Configuration.QuoteChar) >= 0)
{
if (!Configuration.EscapeQuoteAndDelimiter)
{
fieldValue = fieldValue.Replace(Configuration.QuoteChar.ToString(), Configuration.DoubleQuoteChar);
}
else
{
fieldValue = fieldValue.Replace(Configuration.QuoteChar.ToString(), "\\{0}".FormatString(Configuration.QuoteChar));
}
quoteValue = true;
}
if (fieldValue.IndexOf(Configuration.Delimiter) >= 0)
{
if (isHeader)
{
if (fieldConfig == null || fieldConfig.ValueSelector == null)
{
throw new ChoParserException("Field header '{0}' value contains delimiter character.".FormatString(fieldName));
}
}
else
{
//Fields with embedded commas must be delimited with double-quote characters.
if (Configuration.EscapeQuoteAndDelimiter)
{
fieldValue = fieldValue.Replace(Configuration.Delimiter, "\\{0}".FormatString(Configuration.Delimiter));
}
quoteValue = true;
//throw new ChoParserException("Field '{0}' value contains delimiter character.".FormatString(fieldName));
}
}
if (fieldValue.IndexOf(Configuration.EOLDelimiter) >= 0)
{
if (isHeader)
{
throw new ChoParserException("Field header '{0}' value contains EOL delimiter character.".FormatString(fieldName));
}
else
{
//A field that contains embedded line-breaks must be surounded by double-quotes
//if (Configuration.EscapeQuoteAndDelimiters)
// fieldValue = fieldValue.Replace(Configuration.EOLDelimiter, "\\{0}".FormatString(Configuration.EOLDelimiter));
quoteValue = true;
//throw new ChoParserException("Field '{0}' value contains EOL delimiter character.".FormatString(fieldName));
}
}
}
if (!isHeader)
{
//Fields with leading or trailing spaces must be delimited with double-quote characters.
if (!fieldValue.IsNullOrWhiteSpace() && (char.IsWhiteSpace(fieldValue[0]) || char.IsWhiteSpace(fieldValue[fieldValue.Length - 1])))
{
quoteValue = true;
}
}
}
else
{
quoteValue = quoteField.Value;
}
}
//}
//else
//{
// if (fieldValue.StartsWith(Configuration.QuoteChar.ToString()) && fieldValue.EndsWith(Configuration.QuoteChar.ToString()))
// {
// }
// else
// {
// //Fields that contain double quote characters must be surrounded by double-quotes, and the embedded double-quotes must each be represented by a pair of consecutive double quotes.
// if (fieldValue.IndexOf(Configuration.QuoteChar) >= 0)
// {
// fieldValue = "{1}{0}{1}".FormatString(fieldValue.Replace(Configuration.QuoteChar.ToString(), Configuration.DoubleQuoteChar), Configuration.QuoteChar);
// }
// else
// fieldValue = "{1}{0}{1}".FormatString(fieldValue, Configuration.QuoteChar);
// }
//}
//if (quoteValue)
// size = size - 2;
if (fieldValue.IsNullOrEmpty())
{
if (nullValue != null)
{
fieldValue = nullValue;
}
}
if (size != null)
{
if (quoteValue)
{
size = size.Value - 2;
}
if (size <= 0)
{
return(String.Empty);
}
if (fieldValue.Length < size.Value)
{
if (fillChar != ChoCharEx.NUL)
{
if (fieldValueJustification == ChoFieldValueJustification.Right)
{
fieldValue = fieldValue.PadLeft(size.Value, fillChar);
}
else if (fieldValueJustification == ChoFieldValueJustification.Left)
{
fieldValue = fieldValue.PadRight(size.Value, fillChar);
}
}
}
else if (fieldValue.Length > size.Value)
{
if (truncate)
{
if (fieldValueTrimOption != null)
{
if (fieldValueTrimOption == ChoFieldValueTrimOption.TrimStart)
{
fieldValue = fieldValue.Right(size.Value);
}
else
{
fieldValue = fieldValue.Substring(0, size.Value);
}
}
else
{
fieldValue = fieldValue.Substring(0, size.Value);
}
}
else
{
if (isHeader)
{
throw new ApplicationException("Field header value length overflowed for '{0}' member [Expected: {1}, Actual: {2}].".FormatString(fieldName, size, fieldValue.Length));
}
else
{
throw new ApplicationException("Field value length overflowed for '{0}' member [Expected: {1}, Actual: {2}].".FormatString(fieldName, size, fieldValue.Length));
}
}
}
}
if (fieldConfig != null && fieldConfig.ValueSelector != null)
{
quoteValue = false;
}
if (quoteValue)
{
fieldValue = "{1}{0}{1}".FormatString(fieldValue, Configuration.QuoteChar);
}
return(fieldValue);
}
public ChoFixedLengthReader <T> WithField(string fieldName, int startIndex, int size, Type fieldType, bool?quoteField = null, ChoFieldValueTrimOption?fieldValueTrimOption = null)
{
if (!fieldName.IsNullOrEmpty())
{
if (!_clearFields)
{
Configuration.FixedLengthRecordFieldConfigurations.Clear();
_clearFields = true;
}
Configuration.FixedLengthRecordFieldConfigurations.Add(new ChoFixedLengthRecordFieldConfiguration(fieldName.Trim(), startIndex, size)
{
FieldType = fieldType, QuoteField = quoteField, FieldValueTrimOption = fieldValueTrimOption
});
}
return(this);
}
