private void HandleFieldValueWriteReady(object sender, FtFieldValueReadyEventArgs e)
{
FtField field = e.Field;
int recordIndex = e.RecordIndex;
field.AsObject = CalculateValue(field.Id, recordIndex);
}
private void HandleFieldValueWriteReady(object sender, FtFieldValueReadyEventArgs e)
{
FtField field = e.Field;
int recordIndex = e.RecordIndex;
field.AsObject = values[recordIndex, field.Id];
}
private void HandleFieldHeadingWriteReady(object sender, FtFieldHeadingReadyEventArgs e)
{
FtField field = e.Field;
int lineIndex = e.LineIndex;
field.Headings[lineIndex] = CalculateHeading(field.Id, lineIndex);
}
private void WriteRecord()
{
CheckWritePendingEndOfLine();
int recordIndex = recordCount;
recordCount++;
OnRecordStarted(recordIndex);
FtField field = null;
activeFieldIndex = 0;
while (activeFieldIndex < FieldList.Count)
{
// field points to previous field
if (field != null && !field.FixedWidth)
{
writer.Write(DelimiterChar);
}
field = FieldList[activeFieldIndex];
WriteRecordField(field, recordIndex);
activeFieldIndex++;
}
activeFieldIndex = -1;
WriteOrPendEndOfLine();
OnRecordFinished(recordIndex);
}
private void WriteHeadingLine(int headingLineIndex)
{
CheckWritePendingEndOfLine();
OnHeadingLineStarted(headingLineIndex);
FtField field = null;
activeFieldIndex = 0;
while (activeFieldIndex < FieldList.Count)
{
// field points to previous field
if (field != null && !field.FixedWidth)
{
writer.Write(DelimiterChar);
}
field = FieldList[activeFieldIndex];
OnFieldHeadingWriteReady(field, headingLineIndex);
WriteHeadingField(field, headingLineIndex);
activeFieldIndex++;
}
activeFieldIndex = -1;
WriteOrPendEndOfLine();
OnHeadingLineFinished(headingLineIndex);
}
protected void OnSequenceRedirected(FtField redirectingField, int fieldsAffectedFromIndex)
{
if (SequenceRedirected != null)
{
FtSequenceRedirectedEventArgs e = new FtSequenceRedirectedEventArgs();
e.RedirectingField = redirectingField;
e.FieldsAffectedFromIndex = fieldsAffectedFromIndex;
SequenceRedirected.Invoke(this, e);
}
}
internal protected void OnFieldValueWriteReady(FtField field, int recordIndex)
{
if (FieldValueWriteReady != null)
{
FtFieldValueReadyEventArgs e = new FtFieldValueReadyEventArgs();
e.Field = field;
e.RecordIndex = recordIndex;
FieldValueWriteReady.Invoke(this, e);
}
}
internal protected void OnFieldHeadingWriteReady(FtField field, int lineIndex)
{
if (FieldHeadingWriteReady != null)
{
FtFieldHeadingReadyEventArgs e = new FtFieldHeadingReadyEventArgs();
e.Field = field;
e.LineIndex = lineIndex;
FieldHeadingWriteReady.Invoke(this, e);
}
}
internal void EnterField(FtField aField)
{
field = aField;
// cache field values
fieldWidth = field.Width;
if (headings)
{
fieldLeftPad = field.Definition.HeadingLeftPad;
fieldPadCharType = field.HeadingPadCharType;
fieldEndOfValueChar = field.HeadingEndOfValueChar;
fieldPadChar = field.HeadingPadChar;
}
else
{
fieldLeftPad = field.Definition.ValueLeftPad;
fieldPadCharType = field.ValuePadCharType;
fieldEndOfValueChar = field.ValueEndOfValueChar;
fieldPadChar = field.ValuePadChar;
}
if (fieldLeftPad)
{
if (fieldPadCharType == FtPadCharType.EndOfValue)
{
state = State.WaitingLeftEndOfValue;
}
else
{
state = State.LeftPadding;
}
}
else
{
if (fieldPadCharType == FtPadCharType.EndOfValue)
{
state = State.WaitingRightEndOfValue;
}
else
{
state = State.WaitingRightPadding;
}
}
textBuilder.Clear();
position = charReader.Position;
fieldLength = 0;
rawOffset = 0;
rawLength = 0;
rightPaddingCharCount = 0;
}
/*protected void InvokeRootSequenceFromPrevious()
* {
* // NOT USED. Optimisation for InvokingRoot from Previous as used in SerializatonWriter
*
* // SequenceInvokationList however FieldList matches PreviousRecordSequenceInvokationList
*
* // Make SequenceInvokationList hold root only
* SequenceInvokationList.New(RootSequence, 0);
*
* // Adjust FieldList based on PreviousRecordSequenceInvokationList
* // if PreviousRecordSequenceInvokationList = 1 (wont be 0), then FieldList already only contains root fields
* if (PreviousRecordSequenceInvokationList.Count <= 1)
* ResetAllFieldValues();
* else
* {
* // if root sequence was not redirected before its end, keep existing as prediction
* FtSequenceInvokation secondInvokation = PreviousRecordSequenceInvokationList[1];
* if (secondInvokation.StartFieldIndex == RootFieldCount)
* {
* FieldList.PredictTrim(RootFieldCount);
* ResetAllFieldValues();
* }
* else
* {
* int replaceFieldFromIndex = secondInvokation.StartFieldIndex;
* FieldList.Trim(replaceFieldFromIndex);
* ResetAllFieldValues();
* for (int i = replaceFieldFromIndex; i < RootFieldCount; i++)
* {
* FieldList.New(RootSequenceInvokation, RootSequence.ItemList[i]);
* }
* }
* }
* }*/
private void HandleSequenceRedirectEvent(FtField field, FtSequence invokedSequence, FtSequenceInvokationDelay invokationDelay,
out int fieldsAffectedFromIndex)
{
if (invokedSequence != null)
{
Redirect(field, invokedSequence, invokationDelay, out fieldsAffectedFromIndex);
}
else
{
Unredirect(field, out fieldsAffectedFromIndex);
}
}
public string GetString(int idx)
{
FtField field = FieldList[idx];
if (field.DataType != FtStandardDataType.String)
{
throw new InvalidCastException(string.Format(Properties.Resources.SerializationReader_GetString_InvalidCast, field.DataTypeName));
}
else
{
return(((FtStringField)field).Value);
}
}
public void SetString(int idx, string value)
{
FtField field = FieldList[idx];
if (field.DataType != FtStandardDataType.String)
{
throw new InvalidCastException(string.Format(Properties.Resources.SerializationWriter_SetString_InvalidCast, field.DataTypeName));
}
else
{
((FtStringField)field).Value = value;
}
}
private void EnterField(FtField field)
{
activeField = field;
fieldCount++;
if (activeField.FixedWidth)
{
state = State.InFixedWidthField;
fixedWidthFieldParser.EnterField(activeField);
}
else
{
state = State.InDelimitedField;
delimitedFieldParser.EnterField(activeField);
}
}
internal HeadingLineRecordParser(SerializationCore myCore, CharReader myCharReader, bool forheadingLines)
{
core = myCore;
charReader = myCharReader;
headingLines = forheadingLines;
delimitedFieldParser = new DelimitedFieldParser(core, charReader, forheadingLines);
fixedWidthFieldParser = new FixedWidthFieldParser(core, charReader, forheadingLines);
index = -1;
state = State.Out;
fieldCount = 0;
activeField = null;
startPosition = -1;
ignoreExtraCharsStartPosition = -1;
}
private void ExitActiveField()
{
switch (state)
{
case State.InFixedWidthField:
fixedWidthFieldParser.ExitField();
break;
case State.InDelimitedField:
delimitedFieldParser.ExitField();
break;
default:
throw FtInternalException.Create(InternalError.HeadingLineRecordParser_ExitActiveField_UnsupportedState, state.ToString());
}
activeField = null;
}
internal void EnterField(FtField aField)
{
field = aField;
// cache field values
fieldSubstitutionsEnabled = core.SubstitutionsEnabled;
fieldSubstitutionChar = core.SubstitutionChar;
fieldDelimiterChar = core.DelimiterChar;
fieldQuoteChar = core.QuoteChar;
if (headings)
{
fieldQuotedType = field.HeadingQuotedType;
}
else
{
fieldQuotedType = field.ValueQuotedType;
}
switch (fieldQuotedType)
{
case FtQuotedType.Never:
quotedState = QuotedState.NeverOpen;
break;
case FtQuotedType.Optional:
quotedState = QuotedState.CanOpen;
break;
case FtQuotedType.Always:
quotedState = QuotedState.MustOpen;
break;
default:
throw FtInternalException.Create(InternalError.DelimitedFieldParser_EnterField_UnsupportedQuotedType, fieldQuotedType.ToString());
}
textBuilder.Clear();
position = charReader.Position;
rawOffset = -1;
rawLength = 0;
}
internal DelimitedFieldParser(SerializationCore myCore, CharReader myCharReader, bool forHeadings)
{
headings = forHeadings;
charReader = myCharReader;
core = myCore;
textBuilder = new StringBuilder(20);
field = null;
fieldQuotedType = FtQuotedType.Optional;
fieldSubstitutionsEnabled = false;
fieldSubstitutionChar = '\0';
fieldDelimiterChar = '\0';
fieldQuoteChar = '\0';
quotedState = QuotedState.CanOpen;
substitutionActive = false;
position = -1;
rawOffset = -1;
rawLength = 0;
}
private string EncodeFixedWidthHeadingText(string text, FtField field)
{
int textLength = text.Length;
if (textLength == field.Width)
{
return(text);
}
else
{
if (textLength < field.Width)
{
return(PadFixedWidthText(text, field.Definition, field.HeadingPadAlignment, field.HeadingPadCharType, field.HeadingPadChar, field.HeadingEndOfValueChar));
}
else
{
return(TruncateFixedWidthText(text, field.Definition, field.HeadingTruncateType, field.HeadingTruncateChar, field.HeadingTruncateChar /* Headings should never Null truncate*/));
}
}
}
private string EncodeFixedWidthValueText(string text, FtField field)
{
int textLength = text.Length;
if (textLength == field.Width)
{
return(text);
}
else
{
if (textLength < field.Width)
{
return(PadFixedWidthText(text, field.Definition, field.ValuePadAlignment, field.ValuePadCharType, field.ValuePadChar, field.ValueEndOfValueChar));
}
else
{
return(TruncateFixedWidthText(text, field.Definition, field.ValueTruncateType, field.ValueTruncateChar, field.ValueNullChar));
}
}
}
internal FixedWidthFieldParser(SerializationCore myCore, CharReader myCharReader, bool forHeadings)
{
headings = forHeadings;
charReader = myCharReader;
core = myCore;
textBuilder = new StringBuilder(20);
state = State.NoMorePadding;
field = null;
position = -1;
fieldLength = 0;
rawOffset = -1;
rawLength = 0;
fieldWidth = 0;
fieldLeftPad = false;
fieldPadCharType = FtPadCharType.Auto;
fieldEndOfValueChar = '\0';
fieldPadChar = '\0';
rightPaddingCharCount = 0;
}
// remove all sequences after that which contains unRedirecting Field
protected void Unredirect(FtField unredirectingField, out int fieldsAffectedFromIndex)
{
FtSequenceInvokation unredirectingInvokation = unredirectingField.SequenceInvokation;
int unredirectingInvokationIndex = unredirectingInvokation.Index;
if (unredirectingInvokationIndex >= SequenceInvokationList.Count - 1)
{
// unRedirectingInvokationIndex is last. Nothing to do. (should never happen)
fieldsAffectedFromIndex = FtField.NoFieldsAffectedIndex;
}
else
{
int nextInvokationIndex = unredirectingInvokationIndex + 1;
SequenceInvokationList.PredictTrim(nextInvokationIndex);
fieldsAffectedFromIndex = unredirectingInvokation.StartFieldIndex + unredirectingInvokation.FieldsSidelinedFromIndex;
fieldList.Trim(fieldsAffectedFromIndex);
for (int i = unredirectingInvokation.FieldsSidelinedFromIndex; i < unredirectingInvokation.FieldCount; i++)
{
fieldList.Add(unredirectingInvokation.GetField(i));
}
unredirectingInvokation.UnsidelineFields();
}
}
internal override bool CheckTriggered(FtField field)
{
return(field.IsNull());
}
private void WriteRecordField(FtField field, int recordIndex)
{
OnFieldValueWriteReady(field, recordIndex);
if (field.FixedWidth)
{
if (field.IsNull())
{
writer.Write(field.Definition.FixedWidthNullValueText);
}
else
{
string valueText = field.GetAsNonNullValueText();
string rawText = EncodeFixedWidthValueText(valueText, field);
writer.Write(rawText);
}
}
else
{
if (field.IsNull())
{
writer.Write("");
}
else
{
string valueText = field.GetAsNonNullValueText();
bool fieldQuoted;
switch (field.ValueQuotedType)
{
case FtQuotedType.Never:
fieldQuoted = false;
break;
case FtQuotedType.Always:
fieldQuoted = true;
break;
case FtQuotedType.Optional:
if (field.ValueAlwaysWriteOptionalQuote)
{
fieldQuoted = true;
}
else
{
fieldQuoted = DoesTextRequireQuotes(valueText, field.ValueWritePrefixSpace);
}
break;
default:
throw FtInternalException.Create(InternalError.SerializationWriter_WriteRecordField_UnsupportedQuotedType, field.HeadingQuotedType.ToString());
}
if (field.ValueWritePrefixSpace)
{
writer.Write(PrefixSpaceChar);
}
if (fieldQuoted)
{
writer.Write(QuoteChar);
}
string rawText = EncodeDelimitValueHeadingText(valueText, fieldQuoted);
writer.Write(rawText);
if (fieldQuoted)
{
writer.Write(QuoteChar);
}
}
}
if (!field.Constant && !field.ValueAssigned)
{
// Field was not assigned a value (or null) so it will be null but any null sequence redirects will not have been processed yet. Do so now.
Debug.Assert(field.IsNull());
int fieldsAffectedFromIndex;
field.CheckNullSequenceRedirect(out fieldsAffectedFromIndex);
}
}
protected void Redirect(FtField redirectingField, FtSequence invokedSequence, FtSequenceInvokationDelay invokationDelay,
out int fieldsAffectedFromIndex)
{
FtSequenceInvokation redirectingInvokation = redirectingField.SequenceInvokation;
int newInvokationIndex = redirectingInvokation.Index + 1;
int newInvokationStartFieldIndex;
switch (invokationDelay)
{
case FtSequenceInvokationDelay.ftikAfterField:
newInvokationStartFieldIndex = redirectingField.Index + 1;
break;
case FtSequenceInvokationDelay.ftikAfterSequence:
newInvokationStartFieldIndex = redirectingInvokation.StartFieldIndex + redirectingInvokation.FieldCount;
break;
default:
throw FtInternalException.Create(InternalError.Core_InvokeSequences_UnsupportedInvokationDelay, invokationDelay.ToString());
}
// check if redirect does not cause any change
bool changeRequired;
if (newInvokationIndex >= sequenceInvokationList.Count)
{
changeRequired = true;
}
else
{
FtSequenceInvokation nextExistingInvokation = sequenceInvokationList[newInvokationIndex];
changeRequired = (nextExistingInvokation.Sequence != invokedSequence || nextExistingInvokation.StartFieldIndex != newInvokationStartFieldIndex);
}
if (!changeRequired)
{
fieldsAffectedFromIndex = FtField.NoFieldsAffectedIndex;
}
else
{
FtField existingRedirectingField = redirectingInvokation.RedirectingField;
int unredirectfieldsAffectedFromIndex;
if (existingRedirectingField == null)
{
unredirectfieldsAffectedFromIndex = redirectingInvokation.StartFieldIndex + redirectingInvokation.FieldCount;
}
else
{
Unredirect(existingRedirectingField, out unredirectfieldsAffectedFromIndex);
if (unredirectfieldsAffectedFromIndex < 0)
{
// if not affected, set to value which will be higher than new invokation affects fields index
unredirectfieldsAffectedFromIndex = redirectingInvokation.StartFieldIndex + redirectingInvokation.FieldCount;
}
}
FtSequenceInvokation newInvokation = SequenceInvokationList.TryPredictedNew(newInvokationIndex, invokedSequence, newInvokationStartFieldIndex);
if (newInvokation == null)
{
SequenceInvokationList.Trim(newInvokationIndex);
newInvokation = SequenceInvokationList.New(invokedSequence, newInvokationStartFieldIndex);
}
FieldList.Trim(newInvokationStartFieldIndex);
for (int i = 0; i < newInvokation.FieldCount; i++)
{
FieldList.Add(newInvokation.GetField(i));
}
if (newInvokationStartFieldIndex < redirectingInvokation.StartFieldIndex + redirectingInvokation.FieldCount)
{
redirectingInvokation.SidelineFields(newInvokationStartFieldIndex);
}
if (unredirectfieldsAffectedFromIndex < newInvokationStartFieldIndex)
{
fieldsAffectedFromIndex = unredirectfieldsAffectedFromIndex;
}
else
{
fieldsAffectedFromIndex = newInvokationStartFieldIndex;
}
if (!seeking)
{
OnSequenceRedirected(redirectingField, fieldsAffectedFromIndex);
}
}
}
private void WriteHeadingField(FtField field, int headingLineIndex)
{
string headingText = field.Headings[headingLineIndex];
if (headingText == null)
{
headingText = "";
}
if (field.FixedWidth)
{
string rawText = EncodeFixedWidthHeadingText(headingText, field);
writer.Write(rawText);
}
else
{
bool fieldQuoted;
switch (field.HeadingQuotedType)
{
case FtQuotedType.Never:
fieldQuoted = false;
break;
case FtQuotedType.Always:
fieldQuoted = true;
break;
case FtQuotedType.Optional:
if (field.HeadingAlwaysWriteOptionalQuote)
{
fieldQuoted = true;
}
else
{
fieldQuoted = DoesTextRequireQuotes(headingText, field.HeadingWritePrefixSpace);
}
break;
default:
throw FtInternalException.Create(InternalError.SerializationWriter_WriteHeadingField_UnsupportedQuotedType, field.HeadingQuotedType.ToString());
}
if (field.HeadingWritePrefixSpace)
{
writer.Write(PrefixSpaceChar);
}
if (fieldQuoted)
{
writer.Write(QuoteChar);
}
string rawText = EncodeDelimitValueHeadingText(headingText, fieldQuoted);
writer.Write(rawText);
if (fieldQuoted)
{
writer.Write(QuoteChar);
}
}
}
internal void ExitField()
{
textBuilder.Clear();
field = null;
}
