private void AllDefaults_Field(FtMetaField field, FtMetaSequence sequence, FtMetaSequence targetSequence, int redirectType, int itemIdx)
{
const FtSequenceInvokationDelay SequenceInvokationDelay = FtSequenceInvokationDelay.ftikAfterField;
if (state == State.Initialise)
{
defaultMetaFieldProperties.LoadIntoMetaField(ref field, false);
FtMetaSequenceItem sequenceItem = sequence.ItemList.New();
sequenceItem.Field = field;
FtMetaSequenceRedirect sequenceRedirect = sequenceItem.RedirectList.New(redirectType);
sequenceRedirect.InvokationDelay = SequenceInvokationDelay;
sequenceRedirect.Sequence = targetSequence;
}
else
{
defaultMetaFieldProperties.AssertMetaFieldAreEqual(field, false);
FtMetaSequenceItem sequenceItem = sequence.ItemList[itemIdx];
Assert.AreEqual <FtMetaField>(field, sequenceItem.Field);
FtMetaSequenceRedirect sequenceRedirect = sequenceItem.RedirectList[0];
Assert.AreEqual <FtSequenceInvokationDelay>(SequenceInvokationDelay, sequenceRedirect.InvokationDelay);
Assert.AreEqual <FtMetaSequence>(targetSequence, sequenceRedirect.Sequence);
}
}
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
}
}
internal static bool TryParseAttributeValue(string attributeValue, out FtSequenceInvokationDelay enumerator)
{
enumerator = FtSequenceInvokationDelay.ftikAfterField; // avoid compiler error
bool result = false;
foreach (FormatRec rec in formatRecArray)
{
if (String.Equals(rec.AttributeValue, attributeValue, StringComparison.OrdinalIgnoreCase))
{
enumerator = rec.Enumerator;
result = true;
break;
}
}
return(result);
}
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];
}
}
}
private void HandleSequenceRedirectEvent(FtField field, FtSequence sequence, FtSequenceInvokationDelay delay,
out int fieldsAffectedFromIndex)
{
if (field != redirectingField)
{
if (sequence == null)
{
fieldsAffectedFromIndex = FtField.NoFieldsAffectedIndex;
}
else
{
SequenceRedirectEvent(field, sequence, delay, out fieldsAffectedFromIndex);
redirectingField = field;
}
}
else
{
SequenceRedirectEvent(field, sequence, delay, out fieldsAffectedFromIndex);
if (sequence == null)
{
redirectingField = null;
}
}
}
private void LoadBaseDefaults()
{
InvokationDelay = DefaultInvokationDelay;
}
private void HandleSequenceRedirectEvent(FtField field, FtSequence sequence, FtSequenceInvokationDelay delay,
out int fieldsAffectedFromIndex)
{
SequenceRedirectEvent(field, sequence, delay, out fieldsAffectedFromIndex);
}
protected void OnSequenceRedirect(FtSequence sequence, FtSequenceInvokationDelay delay, out int fieldsAffectedFromIndex)
{
SequenceRedirectEvent(this, sequence, delay, out fieldsAffectedFromIndex);
}
internal static string ToAttributeValue(FtSequenceInvokationDelay enumerator)
{
return(formatRecArray[(int)enumerator].AttributeValue);
}
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);
}
}
}
/*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);
}
}
