internal void LoadHeading(int idx,
string headingText)
{
switch (definition.HeadingConstraint)
{
case FtHeadingConstraint.None:
headings[idx] = headingText;
break;
case FtHeadingConstraint.AllConstant:
if (headingText != headings[idx])
{
throw new FtSerializationException(FtSerializationError.FieldConstNameHeadingMismatch, this, string.Format(Properties.Resources.FtField_LoadHeading_AllConstantViolation, idx));
}
break;
case FtHeadingConstraint.MainConstant:
if (idx != definition.MainHeadingIndex)
{
headings[idx] = headingText;
}
else
{
if (headingText != headings[idx])
{
throw new FtSerializationException(FtSerializationError.FieldConstNameHeadingMismatch, this, Properties.Resources.FtField_LoadHeading_MainConstantViolation);
}
}
break;
case FtHeadingConstraint.NameConstant:
if (idx != definition.MainHeadingIndex)
{
headings[idx] = headingText;
}
else
{
if (string.Equals(headingText, definition.MetaName, StringComparison.OrdinalIgnoreCase))
{
headings[idx] = headingText;
}
else
{
throw new FtSerializationException(FtSerializationError.FieldConstNameHeadingMismatch, this, Properties.Resources.FtField_LoadHeading_NameConstantViolation);
}
}
break;
case FtHeadingConstraint.NameIsMain:
headings[idx] = headingText;
if (idx == definition.MainHeadingIndex)
{
name = headingText;
}
break;
default:
throw FtInternalException.Create(InternalError.FtField_ParseHeadingText_UnsupportedHeadingConstraint, definition.HeadingConstraint.ToString());
}
}
internal static void StaticTest()
{
for (int i = 0; i < typeRecArray.Length; i++)
{
if (typeRecArray[i].Type != i)
{
throw FtInternalException.Create(InternalError.FtStandardDataType_StaticTest_TypeRecOutOfOrder, typeRecArray[i].ToString());
}
}
}
internal static void StaticTest()
{
for (int i = 0; i < typeRecArray.Length; i++)
{
if (typeRecArray[i].Type != i)
{
throw FtInternalException.Create(InternalError.FtStandardSequenceRedirectType_StaticTest_TypeRecOutOfOrder);
}
}
}
internal void LoadDelimitedValue(string valueText, bool quoted)
{
loadedValueText = valueText;
try
{
if (quoted)
{
LoadNonNullValue(valueText);
}
else
{
if (valueTextNullTrimmable)
{
valueText = valueText.Trim();
if (valueText.Length == 0)
{
LoadNullValue();
}
else
{
LoadNonNullValue(valueText);
}
}
else
{
if (valueText.Length != 0)
{
LoadNonNullValue(valueText);
}
else
{
switch (ValueQuotedType)
{
case FtQuotedType.Never:
case FtQuotedType.Optional:
LoadNonNullValue(valueText);
break;
case FtQuotedType.Always:
LoadNullValue();
break;
default:
throw FtInternalException.Create(InternalError.FtField_LoadDelimitedValue_UnsupportedValueQuotedType, ValueQuotedType.ToString());
}
}
}
}
}
catch (FtSerializationException E)
{
throw new FtSerializationException(E.Error, this, string.Format(Properties.Resources.FtField_LoadDelimitedValue_Prefix, E.Message), E);
}
}
internal void LoadMeta(FtMetaSequenceItem metaSequenceItem, FtMetaFieldList metaFieldList, FtFieldDefinitionList fieldDefinitionList)
{
int fieldIdx = metaFieldList.IndexOf(metaSequenceItem.Field);
if (fieldIdx < 0)
{
throw FtInternalException.Create(InternalError.FtSequenceItem_LoadMeta_MetaSequenceItemFieldNotFoundInMetaFieldList, metaSequenceItem.Field.Name); // should never happen
}
else
{
fieldDefinition = fieldDefinitionList[fieldIdx]; // fieldDefinitions are in same order as Meta Fields
}
}
internal protected virtual void LoadMeta(FtMetaSequenceRedirect metaSequenceRedirect, FtMetaSequenceList metaSequenceList, FtSequenceList sequenceList)
{
type = metaSequenceRedirect.Type;
invokationDelay = metaSequenceRedirect.InvokationDelay;
int sequenceIdx = metaSequenceList.IndexOf(metaSequenceRedirect.Sequence);
if (sequenceIdx < 0)
{
throw FtInternalException.Create(InternalError.FtSequenceRedirect_LoadMeta_MetaSequenceRedirectSequenceNotFoundInMetaSequenceList, metaSequenceRedirect.Sequence.Name); // should never happen
}
else
{
sequence = sequenceList[sequenceIdx]; // sequenceList are in same order as Meta Sequence List
}
}
protected internal void AssignExcludingRedirects(FtMetaSequenceItem source, FtMetaFieldList fieldList, FtMetaFieldList sourceFieldList)
{
int fieldIndex = sourceFieldList.IndexOf(source.Field);
if (fieldIndex < 0)
{
throw FtInternalException.Create(InternalError.FtMetaSequenceItem_AssignExcludingRedirects_SourceFieldNotFound); // should never happen
}
else
{
if (fieldIndex >= fieldList.Count)
{
throw FtInternalException.Create(InternalError.FtMetaSequenceItem_AssignExcludingRedirects_FieldIndexOutOfRange, fieldIndex.ToString()); // should never happen
}
else
{
Field = fieldList[fieldIndex];
}
}
}
protected internal virtual void Assign(FtMetaSequenceRedirect source, FtMetaSequenceList sequenceList, FtMetaSequenceList sourceSequenceList)
{
InvokationDelay = source.InvokationDelay;
int sequenceIndex = sourceSequenceList.IndexOf(source.Sequence);
if (sequenceIndex < 0)
{
throw FtInternalException.Create(InternalError.FtMetaSequenceItem_Assign_SourceFieldNotFound); // should never happen
}
else
{
if (sequenceIndex >= sequenceList.Count)
{
throw FtInternalException.Create(InternalError.FtMetaSequenceItem_Assign_FieldIndexOutOfRange, sequenceIndex.ToString()); // should never happen
}
else
{
Sequence = sequenceList[sequenceIndex];
}
}
}
public void LoadMeta(FtMetaSubstitution metaSubstitution, FtEndOfLineAutoWriteType autoWriteType)
{
type = metaSubstitution.Type;
token = metaSubstitution.Token;
switch (type)
{
case FtSubstitutionType.String:
value = metaSubstitution.Value;
break;
case FtSubstitutionType.AutoEndOfLine:
switch (autoWriteType)
{
case FtEndOfLineAutoWriteType.CrLf:
value = SerializationCore.CarriageReturnLineFeedString;
break;
case FtEndOfLineAutoWriteType.Cr:
value = SerializationCore.CarriageReturnChar.ToString();
break;
case FtEndOfLineAutoWriteType.Lf:
value = SerializationCore.LineFeedChar.ToString();
break;
case FtEndOfLineAutoWriteType.Local:
value = System.Environment.NewLine;
break;
default:
throw FtInternalException.Create(InternalError.FtSubstitution_LoadMeta_UnsupportedAutoWriteType, autoWriteType.ToString());
}
value = metaSubstitution.Value;
break;
}
}
public bool Validate(out string errorMessage)
{
// check various - including multiple sequence roots and duplicate sequence names
errorMessage = "";
foreach (ValidateTest test in Enum.GetValues(typeof(ValidateTest)))
{
switch (test)
{
case ValidateTest.FieldList:
if (FieldList.Count == 0)
{
errorMessage = Properties.Resources.FtMeta_Validate_MustHaveAtLeastOneField;
}
break;
case ValidateTest.QuoteCharSameAsDelimiterChar:
if (QuoteChar == DelimiterChar)
{
errorMessage = Properties.Resources.FtMeta_Validate_QuoteCharAndDelimiterCharMustBeDifferent;
}
break;
case ValidateTest.QuoteCharSameAsLineCommentChar:
if (QuoteChar == LineCommentChar)
{
errorMessage = Properties.Resources.FtMeta_Validate_QuoteCharAndLineCommentCharMustBeDifferent;
}
break;
case ValidateTest.LineCommentCharSameAsDelimiterChar:
if (LineCommentChar == DelimiterChar)
{
errorMessage = Properties.Resources.FtMeta_Validate_LineCommentCharAndDelimiterCharMustBeDifferent;
}
break;
case ValidateTest.SubstitutionChar:
if (SubstitutionsEnabled)
{
if (QuoteChar == SubstitutionChar)
{
errorMessage = Properties.Resources.FtMeta_Validate_QuoteCharAndSubstitutionCharMustBeDifferent;
}
else
{
if (DelimiterChar == SubstitutionChar)
{
errorMessage = Properties.Resources.FtMeta_Validate_DelimiterCharAndSubstitutionCharMustBeDifferent;
}
else
{
if (LineCommentChar == SubstitutionChar)
{
errorMessage = Properties.Resources.FtMeta_Validate_LineCommentCharAndSubstitutionCharMustBeDifferent;
}
else
{
}
}
}
}
break;
case ValidateTest.EndOfLineType:
switch (EndOfLineType)
{
case FtEndOfLineType.CrLf:
case FtEndOfLineType.Auto:
if (ValidateEndOfLineTypeChar(Serialization.SerializationCore.CarriageReturnChar, out errorMessage))
{
ValidateEndOfLineTypeChar(Serialization.SerializationCore.LineFeedChar, out errorMessage);
}
break;
case FtEndOfLineType.Char:
ValidateEndOfLineTypeChar(EndOfLineChar, out errorMessage);
break;
default: throw FtInternalException.Create(InternalError.FtMeta_Validate_UnsupportedEndOfLineType);
}
break;
case ValidateTest.SequenceRoot:
string firstRootSequenceName;
string secondRootSequenceName;
if (SequenceList.IsMoreThanOneRoot(out firstRootSequenceName, out secondRootSequenceName))
{
errorMessage = string.Format(Properties.Resources.FtMeta_Validate_MoreThanOneRootSequence, firstRootSequenceName, secondRootSequenceName);
}
break;
case ValidateTest.DuplicateSequenceName:
string duplicateSequenceName;
if (SequenceList.HasDuplicateName(out duplicateSequenceName))
{
errorMessage = string.Format(Properties.Resources.FtMeta_Validate_DuplicateSequenceName, duplicateSequenceName);
}
break;
case ValidateTest.SequenceItemHasNullField:
for (int i = 0; i < SequenceList.Count; i++)
{
int itemIdx;
if (SequenceList[i].AnyItemWithNullField(out itemIdx))
{
errorMessage = string.Format(Properties.Resources.FtMeta_Validate_SequenceItemWithNullField, SequenceList[i].Name, itemIdx);
}
}
break;
case ValidateTest.SequenceItemWithConstantFieldHasRedirects:
for (int i = 0; i < SequenceList.Count; i++)
{
int itemIdx;
if (SequenceList[i].AnyItemWithConstantFieldHasRedirects(out itemIdx))
{
errorMessage = string.Format(Properties.Resources.FtMeta_Validate_SequenceItemWithConstantFieldHasRedirects, SequenceList[i].Name, itemIdx);
}
}
break;
default: throw FtInternalException.Create(InternalError.FtMeta_Validate_UnsupportedValidateTest);
}
if (errorMessage.Length != 0)
{
break;
}
}
return(errorMessage == "");
}
internal protected virtual void LoadMeta(FtMetaField metaField, CultureInfo myCulture, int myMainHeadingIndex)
{
dataType = metaField.DataType;
id = metaField.Id;
metaName = metaField.Name;
metaHeadings = metaField.Headings;
mainHeadingIndex = myMainHeadingIndex;
culture = myCulture;
fixedWidth = metaField.FixedWidth;
width = metaField.Width;
constant = metaField.Constant;
_null = metaField.Null;
valueQuotedType = metaField.ValueQuotedType;
valueAlwaysWriteOptionalQuote = metaField.ValueAlwaysWriteOptionalQuote;
valueWritePrefixSpace = metaField.ValueWritePrefixSpace;
valuePadAlignment = metaField.ValuePadAlignment;
valuePadCharType = metaField.ValuePadCharType;
valuePadChar = metaField.ValuePadChar;
valueTruncateType = metaField.ValueTruncateType;
valueTruncateChar = metaField.ValueTruncateChar;
valueEndOfValueChar = metaField.ValueEndOfValueChar;
valueNullChar = metaField.ValueNullChar;
headingConstraint = metaField.HeadingConstraint;
headingQuotedType = metaField.HeadingQuotedType;
headingAlwaysWriteOptionalQuote = metaField.HeadingAlwaysWriteOptionalQuote;
headingWritePrefixSpace = metaField.HeadingWritePrefixSpace;
headingPadAlignment = metaField.HeadingPadAlignment;
headingPadCharType = metaField.HeadingPadCharType;
headingPadChar = metaField.HeadingPadChar;
headingTruncateType = metaField.HeadingTruncateType;
headingTruncateChar = metaField.HeadingTruncateChar;
headingEndOfValueChar = metaField.HeadingEndOfValueChar;
formatter.Culture = culture;
if (
((headingConstraint == FtHeadingConstraint.NameIsMain) || (headingConstraint == FtHeadingConstraint.NameConstant))
&&
(mainHeadingIndex >= 0)
&&
(mainHeadingIndex < MetaHeadingCount)
)
{
metaHeadings[mainHeadingIndex] = metaName;
}
switch (headingPadAlignment)
{
case FtPadAlignment.Left:
headingLeftPad = true;
break;
case FtPadAlignment.Right:
headingLeftPad = false;
break;
case FtPadAlignment.Auto:
headingLeftPad = autoLeftPad;
break;
default: throw FtInternalException.Create(InternalError.FtFieldFieldDefinition_LoadMeta_UnsupportedHeadingPadAlignment, headingPadAlignment.ToString());
}
switch (valuePadAlignment)
{
case FtPadAlignment.Left:
valueLeftPad = true;
break;
case FtPadAlignment.Right:
valueLeftPad = false;
break;
case FtPadAlignment.Auto:
valueLeftPad = autoLeftPad;
break;
default: throw FtInternalException.Create(InternalError.FtFieldFieldDefinition_LoadMeta_UnsupportedValuePadAlignment, headingPadAlignment.ToString());
}
if (fixedWidth)
{
fixedWidthNullValueText = new string(ValueNullChar, Width);
}
}
public static bool TryParse(string value, bool strict, out string[] resultArray, out string errorDescription)
{
string[] strArray = null;
errorDescription = "";
int count = 0;
InQuotes inQuotes = InQuotes.NotIn;
bool waitingForDelimiter = false;
int startPos = 0;
int valueLength = value.Length;
for (int i = 0; i < valueLength; i++)
{
char valueChar = value[i];
if (waitingForDelimiter)
{
if (valueChar == DelimiterChar)
{
waitingForDelimiter = false;
startPos = i + 1;
}
else
{
if (strict && (!Char.IsWhiteSpace(valueChar)))
{
errorDescription = string.Format(Properties.Resources.FtCommaText_TryParse_UnexpectedCharAfterQuotedElement, i);
break;
}
}
}
else
{
switch (inQuotes)
{
case InQuotes.NotIn:
switch (valueChar)
{
case DelimiterChar:
AddElement(value, ref strArray, ref count, startPos, i, false);
startPos = i + 1;
break;
case QuoteChar:
if (value.Substring(startPos, i - startPos).Trim() == "")
{
inQuotes = InQuotes.In;
startPos = i + 1;
}
break;
}
break;
case InQuotes.In:
if (valueChar == QuoteChar)
{
inQuotes = InQuotes.CheckingStuffed;
}
break;
case InQuotes.CheckingStuffed:
switch (valueChar)
{
case QuoteChar:
inQuotes = InQuotes.In;
break;
case DelimiterChar:
inQuotes = InQuotes.NotIn;
AddElement(value, ref strArray, ref count, startPos, i - 1, true);
startPos = i + 1;
break;
default:
inQuotes = InQuotes.NotIn;
AddElement(value, ref strArray, ref count, startPos, i - 1, true);
waitingForDelimiter = true;
if (strict && (!(Char.IsWhiteSpace(valueChar))))
{
errorDescription = string.Format(Properties.Resources.FtCommaText_TryParse_UnexpectedCharAfterQuotedElement, i);
break;
}
break;
}
break;
default:
throw FtInternalException.Create(InternalError.FtCommaText_TryParse_UnsupportedInQuotes1, inQuotes.ToString());
}
}
}
if ((errorDescription == "") && (!waitingForDelimiter))
{
switch (inQuotes)
{
case InQuotes.NotIn:
if (startPos <= valueLength)
{
AddElement(value, ref strArray, ref count, startPos, valueLength, false);
}
break;
case InQuotes.In:
if (strict)
{
errorDescription = Properties.Resources.FtCommaText_TryParse_QuotesNotClosedInLastElement;
}
else
{
AddElement(value, ref strArray, ref count, startPos, valueLength, true);
}
break;
case InQuotes.CheckingStuffed:
AddElement(value, ref strArray, ref count, startPos, valueLength - 1, true);
break;
default:
throw FtInternalException.Create(InternalError.FtCommaText_TryParse_UnsupportedInQuotes2, inQuotes.ToString());
}
}
resultArray = new string[count];
Array.Copy(strArray, resultArray, count);
return(errorDescription == "");
}