/*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);
}
}
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);
}
}
}
internal void InternalLoadMeta(FtMeta meta)
{
sequenceList.Clear();
substitutionList.Clear();
fieldList.Clear();
fieldDefinitionList.Clear();
string errorMessage;
if (!meta.Validate(out errorMessage))
{
throw new FtSerializationException(FtSerializationError.InvalidMeta, errorMessage);
}
else
{
culture = meta.Culture;
endOfLineType = meta.EndOfLineType;
endOfLineChar = meta.EndOfLineChar;
endOfLineAutoWriteType = meta.EndOfLineAutoWriteType;
lastLineEndedType = meta.LastLineEndedType;
quoteChar = meta.QuoteChar;
delimiterChar = meta.DelimiterChar;
lineCommentChar = meta.LineCommentChar;
allowEndOfLineCharInQuotes = meta.AllowEndOfLineCharInQuotes;
ignoreBlankLines = meta.IgnoreBlankLines;
ignoreExtraChars = meta.IgnoreExtraChars;
allowIncompleteRecords = meta.AllowIncompleteRecords;
stuffedEmbeddedQuotes = meta.StuffedEmbeddedQuotes;
substitutionsEnabled = meta.SubstitutionsEnabled;
substitutionChar = meta.SubstitutionChar;
headingLineCount = meta.HeadingLineCount;
mainHeadingLineIndex = meta.MainHeadingLineIndex;
headingConstraint = meta.HeadingConstraint;
headingQuotedType = meta.HeadingQuotedType;
headingAlwaysWriteOptionalQuote = meta.HeadingAlwaysWriteOptionalQuote;
headingWritePrefixSpace = meta.HeadingWritePrefixSpace;
headingPadAlignment = meta.HeadingPadAlignment;
headingPadCharType = meta.HeadingPadCharType;
headingPadChar = meta.HeadingPadChar;
headingTruncateType = meta.HeadingTruncateType;
headingTruncateChar = meta.HeadingTruncateChar;
headingEndOfValueChar = meta.HeadingEndOfValueChar;
fieldDefinitionList.Capacity = meta.FieldList.Count;
fieldList.Capacity = meta.FieldList.Count;
for (int i = 0; i < meta.FieldList.Count; i++)
{
FtFieldDefinition fieldDefinition = fieldDefinitionList.New(meta.FieldList[i].DataType);
fieldDefinition.LoadMeta(meta.FieldList[i], culture, mainHeadingLineIndex);
}
for (int i = 0; i < meta.SubstitutionList.Count; i++)
{
FtSubstitution substitution = substitutionList.New();
substitution.LoadMeta(meta.SubstitutionList[i], endOfLineAutoWriteType);
}
if (meta.SequenceList.Count == 0)
{
// create a root sequence with all field definitions
rootSequence = sequenceList.New(fieldDefinitionList);
}
else
{
rootSequence = null;
for (int i = 0; i < meta.SequenceList.Count; i++)
{
FtSequence sequence = sequenceList.New();
sequence.LoadMeta(meta.SequenceList[i], meta.FieldList, fieldDefinitionList);
if (sequence.Root)
{
rootSequence = sequence;
}
}
if (rootSequence == null && sequenceList.Count > 0)
{
rootSequence = sequenceList[0];
rootSequence.SetRoot(true);
}
// must load redirects after ALL sequences are loaded
for (int i = 0; i < sequenceList.Count; i++)
{
sequenceList[i].LoadMetaSequenceRedirects(meta.SequenceList[i], meta.SequenceList, sequenceList);
}
}
rootFieldCount = rootSequence.ItemList.Count;
metaLoaded = true;
}
}
