protected virtual bool ResolveProperties(FtMetaSequenceItem item, FtMetaFieldList fieldList, out string errorDescription)
{
errorDescription = "";
bool result = true;
foreach (FtMetaSequenceItem.PropertyId id in Enum.GetValues(typeof(FtMetaSequenceItem.PropertyId)))
{
switch (id)
{
case FtMetaSequenceItem.PropertyId.Index:
// already processed in TryAddOrIgnoreAttribute()
break;
case FtMetaSequenceItem.PropertyId.FieldIndex:
result = ResolveFieldIndex(item, fieldList, out errorDescription);
break;
default:
throw FtInternalException.Create(InternalError.SequenceItemReadElement_ResolveProperties_UnsupportedPropertyId, id.ToString());
}
if (!result)
{
break;
}
}
return(result);
}
// properties
private bool ResolveFieldIndex(FtMetaSequenceItem item, FtMetaFieldList fieldList, out string errorDescription)
{
errorDescription = "";
bool result = true;
string attributeValue;
if (!attributeDictionary.TryGetValue(FtMetaSequenceItem.PropertyId.FieldIndex, out attributeValue))
{
errorDescription = string.Format(Properties.Resources.SequenceItemReadElement_ResolveFieldIndex_Missing);
result = false;
}
else
{
int fieldIndex;
if (FtStandardText.TryParse(attributeValue, out fieldIndex))
{
if (fieldIndex < 0 || fieldIndex >= fieldList.Count)
{
errorDescription = string.Format(Properties.Resources.SequenceItemReadElement_ResolveFieldIndex_OutOfRange, fieldIndex);
}
else
{
item.Field = fieldList[fieldIndex];
}
}
else
{
errorDescription = string.Format(Properties.Resources.SequenceItemReadElement_ResolveFieldIndex_Invalid, attributeValue);
result = false;
}
}
return(result);
}
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 bool ResolveTo(FtMetaSequenceItem item, FtMetaFieldList fieldList, FtMetaSequenceList sequenceList, out string errorDescription)
{
if (!ResolveProperties(item, fieldList, out errorDescription))
{
return(false);
}
else
{
return(ResolveRedirects(item, sequenceList, out errorDescription));
}
}
protected virtual bool ResolveRedirects(FtMetaSequenceItem item, FtMetaSequenceList sequenceList, out string errorDescription)
{
RedirectSorter.Rec[] sorterRecArray = new RedirectSorter.Rec[redirectList.Count];
SequenceRedirectReadElement[] sortedElements;
for (int i = 0; i < redirectList.Count; i++)
{
SequenceRedirectReadElement element = redirectList[i];
sorterRecArray[i].Target = element;
sorterRecArray[i].Implicit = i;
sorterRecArray[i].Explicit = element.ExplicitIndex;
}
int duplicateExplicitIndex;
if (!RedirectSorter.TrySort(sorterRecArray, out sortedElements, out duplicateExplicitIndex))
{
errorDescription = string.Format(Properties.Resources.SequenceItemReadElement_ResolveRedirects_DuplicateExplicitIndex, duplicateExplicitIndex);
return(false);
}
else
{
errorDescription = "";
bool result = true;
for (int i = 0; i < sortedElements.Length; i++)
{
SequenceRedirectReadElement element = sortedElements[i];
int redirectType;
if (element.RedirectType == FtStandardSequenceRedirectType.Unknown)
{
redirectType = item.Field.DefaultSequenceRedirectType;
}
else
{
redirectType = element.RedirectType;
}
FtMetaSequenceRedirect redirect = item.RedirectList.New(redirectType);
if (!element.ResolveTo(redirect, sequenceList, out errorDescription))
{
result = false;
break;
}
}
return(result);
}
}
// This program programmatically generates a Meta file that uses sequences.
// The Meta is for a CSV file which lists 3 types of pets. For each pet the file will specify
// its type and its name. These 2 fields make the root sequence.
// Pet type 1 is cats. For each cat it will specify its running speed (Cat Sequence)
// Pet type 2 is dogs. For each dog it will specify its walking distance, its running speed
// and whether it is being trained. (Dog Sequence)
// If a dog is being trained, it will also specify the trainer and the cost of each
// training session. (Training Sequence)
// Pet type 3 is gold fish. For each gold fish, it will specify its color and
// chinese classification (GoldFish sequence).
static void Main(string[] args)
{
const string MetaFileName = "ExampleSequenceMeta.ftm";
// Define Field Names
const string TypeFieldName = "Type";
const string NameFieldName = "Name";
const string RunningSpeedFieldName = "RunningSpeed";
const string WalkDistanceFieldName = "WalkDistance";
const string TrainingFieldName = "Training";
const string TrainerFieldName = "Trainer";
const string SessionCostFieldName = "SessionCost";
const string ColorFieldName = "Color";
const string ChineseClassificationFieldName = "ChineseClassification";
// Define Field Ids
const int TypeFieldId = 0;
const int NameFieldId = 1;
const int RunningSpeedFieldId = 2;
const int WalkDistanceFieldId = 3;
const int TrainingFieldId = 4;
const int TrainerFieldId = 5;
const int SessionCostFieldId = 6;
const int ColorFieldId = 7;
const int ChineseClassificationFieldId = 8;
// Define Sequence Names
const string RootSequenceName = "Root";
const string CatSequenceName = "Cat";
const string DogSequenceName = "Dog";
const string GoldFishSequenceName = "GoldFish";
const string TrainingSequenceName = "Training";
FtMeta meta = new FtMeta();
// Add fields to Meta
FtMetaField typeField = meta.FieldList.New(FtStandardDataType.Integer);
typeField.Name = TypeFieldName;
typeField.Id = TypeFieldId;
FtMetaField nameField = meta.FieldList.New(FtStandardDataType.String);
nameField.Name = NameFieldName;
nameField.Id = NameFieldId;
FtMetaField runningSpeedField = meta.FieldList.New(FtStandardDataType.Float);
runningSpeedField.Name = RunningSpeedFieldName;
runningSpeedField.Id = RunningSpeedFieldId;
FtMetaField walkDistanceField = meta.FieldList.New(FtStandardDataType.Float);
walkDistanceField.Name = WalkDistanceFieldName;
walkDistanceField.Id = WalkDistanceFieldId;
FtMetaField trainingField = meta.FieldList.New(FtStandardDataType.Boolean);
trainingField.Name = TrainingFieldName;
trainingField.Id = TrainingFieldId;
FtMetaField trainerField = meta.FieldList.New(FtStandardDataType.String);
trainerField.Name = TrainerFieldName;
trainerField.Id = TrainerFieldId;
FtMetaField sessionCostField = meta.FieldList.New(FtStandardDataType.Decimal);
sessionCostField.Name = SessionCostFieldName;
sessionCostField.Id = SessionCostFieldId;
FtMetaField tankLocationField = meta.FieldList.New(FtStandardDataType.String);
tankLocationField.Name = ColorFieldName;
tankLocationField.Id = ColorFieldId;
FtMetaField chineseClassificationField = meta.FieldList.New(FtStandardDataType.String);
chineseClassificationField.Name = ChineseClassificationFieldName;
chineseClassificationField.Id = ChineseClassificationFieldId;
// Add Sequences to Meta
FtMetaSequence rootSequence = meta.SequenceList.New();
rootSequence.Name = RootSequenceName;
rootSequence.Root = true;
FtMetaSequence catSequence = meta.SequenceList.New();
catSequence.Name = CatSequenceName;
FtMetaSequence dogSequence = meta.SequenceList.New();
dogSequence.Name = DogSequenceName;
FtMetaSequence goldFishSequence = meta.SequenceList.New();
goldFishSequence.Name = GoldFishSequenceName;
FtMetaSequence trainingSequence = meta.SequenceList.New();
trainingSequence.Name = TrainingSequenceName;
// Add SequenceItems to Sequences.
// Add SequenceItems with fields in correct order. This way index does not need to be specified
FtMetaSequenceItem item; // used for sequence items without redirects
FtMetaSequenceItem typeSequenceItem = rootSequence.ItemList.New();
typeSequenceItem.Field = typeField;
item = rootSequence.ItemList.New();
item.Field = nameField;
item = catSequence.ItemList.New();
item.Field = runningSpeedField;
item = dogSequence.ItemList.New();
item.Field = walkDistanceField;
item = dogSequence.ItemList.New();
item.Field = runningSpeedField;
FtMetaSequenceItem trainingSequenceItem = dogSequence.ItemList.New();
trainingSequenceItem.Field = trainingField;
item = trainingSequence.ItemList.New();
item.Field = trainerField;
item = trainingSequence.ItemList.New();
item.Field = sessionCostField;
item = goldFishSequence.ItemList.New();
item.Field = tankLocationField;
item = goldFishSequence.ItemList.New();
item.Field = chineseClassificationField;
// Add redirects to Meta Sequence Items.
FtExactIntegerMetaSequenceRedirect typeRedirect;
typeRedirect = typeSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect;
typeRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterSequence;
typeRedirect.Sequence = catSequence;
typeRedirect.Value = 1;
typeRedirect = typeSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect;
typeRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterSequence;
typeRedirect.Sequence = dogSequence;
typeRedirect.Value = 2;
typeRedirect = typeSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect;
typeRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterSequence;
typeRedirect.Sequence = goldFishSequence;
typeRedirect.Value = 3;
FtBooleanMetaSequenceRedirect trainingRedirect;
trainingRedirect = trainingSequenceItem.RedirectList.New(FtStandardSequenceRedirectType.Boolean) as FtBooleanMetaSequenceRedirect;
trainingRedirect.InvokationDelay = FtSequenceInvokationDelay.ftikAfterField;
trainingRedirect.Sequence = trainingSequence;
trainingRedirect.Value = true;
// Save Meta to file
System.Xml.XmlWriterSettings writerSettings = new System.Xml.XmlWriterSettings();
writerSettings.Indent = true;
writerSettings.IndentChars = " ";
FtMetaSerializer.Serialize(meta, MetaFileName, writerSettings);
}
public void MetaSequence()
{
FtMeta meta = new FtMeta();
FtMetaField rootField1 = meta.FieldList.New(FtStandardDataType.String);
rootField1.Id = RootField1Id;
FtMetaField rootField2 = meta.FieldList.New(FtStandardDataType.Integer);
rootField2.Id = RootField2Id;
FtMetaField rootField3 = meta.FieldList.New(FtStandardDataType.Boolean);
rootField3.Id = RootField3Id;
FtMetaField sequence1Field1 = meta.FieldList.New(FtStandardDataType.Float);
sequence1Field1.Id = Sequence1Field1Id;
FtMetaField sequence1Field2 = meta.FieldList.New(FtStandardDataType.Decimal);
sequence1Field2.Id = Sequence1Field2Id;
FtMetaField sequence2Field1 = meta.FieldList.New(FtStandardDataType.DateTime);
sequence2Field1.Id = Sequence2Field1Id;
FtMetaField sequence2Field2 = meta.FieldList.New(FtStandardDataType.Boolean);
sequence2Field2.Id = Sequence2Field2Id;
FtMetaField sequence2Field3 = meta.FieldList.New(FtStandardDataType.String);
sequence2Field3.Id = Sequence2Field3Id;
FtMetaField sequence2Field4 = meta.FieldList.New(FtStandardDataType.Integer);
sequence2Field4.Id = Sequence2Field4Id;
FtMetaField sequence3Field1 = meta.FieldList.New(FtStandardDataType.Boolean);
sequence3Field1.Id = Sequence3Field1Id;
FtMetaField sequence4Field1 = meta.FieldList.New(FtStandardDataType.Float);
sequence4Field1.Id = Sequence4Field1Id;
FtMetaField sequence4Field2 = meta.FieldList.New(FtStandardDataType.Decimal);
sequence4Field2.Id = Sequence4Field2Id;
FtMetaSequence rootSequence = meta.SequenceList.New();
rootSequence.Root = true;
FtMetaSequenceItem rootItem1 = rootSequence.ItemList.New();
rootItem1.Field = rootField1;
FtMetaSequenceItem rootItem2 = rootSequence.ItemList.New();
rootItem2.Field = rootField2;
FtMetaSequenceItem rootItem3 = rootSequence.ItemList.New();
rootItem3.Field = rootField3;
FtMetaSequence sequence1 = meta.SequenceList.New();
sequence1.Name = Sequence1Name;
FtMetaSequenceItem sequence1Item1 = sequence1.ItemList.New();
sequence1Item1.Field = sequence1Field1;
FtMetaSequenceItem sequence1Item2 = sequence1.ItemList.New();
sequence1Item2.Field = sequence1Field2;
FtMetaSequence sequence2 = meta.SequenceList.New();
sequence2.Name = Sequence2Name;
FtMetaSequenceItem sequence2Item1 = sequence2.ItemList.New();
sequence2Item1.Field = sequence2Field1;
FtMetaSequenceItem sequence2Item2 = sequence2.ItemList.New();
sequence2Item2.Field = sequence2Field2;
FtMetaSequenceItem sequence2Item3 = sequence2.ItemList.New();
sequence2Item3.Field = sequence2Field3;
FtMetaSequenceItem sequence2Item4 = sequence2.ItemList.New();
sequence2Item4.Field = sequence2Field4;
FtMetaSequence sequence3 = meta.SequenceList.New();
sequence3.Name = Sequence3Name;
FtMetaSequenceItem sequence3Item1 = sequence3.ItemList.New();
sequence3Item1.Field = sequence3Field1;
FtMetaSequence sequence4 = meta.SequenceList.New();
sequence4.Name = Sequence4Name;
FtMetaSequenceItem sequence4Item1 = sequence4.ItemList.New();
sequence4Item1.Field = sequence4Field1;
FtMetaSequenceItem sequence4Item2 = sequence4.ItemList.New();
sequence4Item2.Field = sequence4Field2;
FtExactIntegerMetaSequenceRedirect rootRedirect1 = rootItem2.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect;
rootRedirect1.InvokationDelay = RootRedirect1InvokationDelay;
rootRedirect1.Value = RootRedirect1Value;
rootRedirect1.Sequence = sequence1;
FtExactIntegerMetaSequenceRedirect rootRedirect2 = rootItem2.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect;
rootRedirect2.InvokationDelay = RootRedirect2InvokationDelay;
rootRedirect2.Value = 2;
rootRedirect2.Sequence = sequence2;
FtExactIntegerMetaSequenceRedirect rootRedirect3 = rootItem2.RedirectList.New(FtStandardSequenceRedirectType.ExactInteger) as FtExactIntegerMetaSequenceRedirect;
rootRedirect3.InvokationDelay = RootRedirect3InvokationDelay;
rootRedirect3.Value = 3;
rootRedirect3.Sequence = sequence3;
FtNullMetaSequenceRedirect sequence1Redirect1 = sequence1Item2.RedirectList.New(FtStandardSequenceRedirectType.Null) as FtNullMetaSequenceRedirect;
sequence1Redirect1.InvokationDelay = Sequence1Redirect1InvokationDelay;
sequence1Redirect1.Sequence = sequence4;
FtCaseInsensitiveStringMetaSequenceRedirect sequence2Redirect1 = sequence2Item3.RedirectList.New(FtStandardSequenceRedirectType.CaseInsensitiveString) as FtCaseInsensitiveStringMetaSequenceRedirect;
sequence2Redirect1.InvokationDelay = Sequence2Redirect1InvokationDelay;
sequence2Redirect1.Value = Sequence2Redirect1Value;
sequence2Redirect1.Sequence = sequence4;
// Serialize Meta
XmlWriter writer = XmlWriter.Create(filePath, xmlWriterSettings);
FtMetaSerializer.Serialize(meta, writer);
writer.Close();
string DataFilePath = Path.Combine(DataFolder, SequenceFileName);
if (!TextFilesAreEqual(filePath, DataFilePath))
{
Assert.Fail("MetaSequence does not match Test Data");
}
else
{
FtMeta deserializedMeta = FtMetaSerializer.Deserialize(filePath);
AssertDeserializedMeta(deserializedMeta);
string foreignFilePath = Path.Combine(DataFolder, ForeignFileName);
FtMeta deserializedForeign = FtMetaSerializer.Deserialize(foreignFilePath);
AssertDeserializedMeta(deserializedForeign);
}
}
private void AssertDeserializedMeta(FtMeta meta)
{
Assert.AreEqual <int>(12, meta.FieldList.Count);
for (int i = 0; i < 12; i++)
{
Assert.AreEqual <int>(i, meta.FieldList[i].Id);
}
FtMetaField rootField1 = meta.FieldList[0];
Assert.AreEqual <int>(FtStandardDataType.String, rootField1.DataType);
FtMetaField rootField2 = meta.FieldList[1];
Assert.AreEqual <int>(FtStandardDataType.Integer, rootField2.DataType);
FtMetaField rootField3 = meta.FieldList[2];
Assert.AreEqual <int>(FtStandardDataType.Boolean, rootField3.DataType);
FtMetaField sequence1Field1 = meta.FieldList[3];
Assert.AreEqual <int>(FtStandardDataType.Float, sequence1Field1.DataType);
FtMetaField sequence1Field2 = meta.FieldList[4];
Assert.AreEqual <int>(FtStandardDataType.Decimal, sequence1Field2.DataType);
FtMetaField sequence2Field1 = meta.FieldList[5];
Assert.AreEqual <int>(FtStandardDataType.DateTime, sequence2Field1.DataType);
FtMetaField sequence2Field2 = meta.FieldList[6];
Assert.AreEqual <int>(FtStandardDataType.Boolean, sequence2Field2.DataType);
FtMetaField sequence2Field3 = meta.FieldList[7];
Assert.AreEqual <int>(FtStandardDataType.String, sequence2Field3.DataType);
FtMetaField sequence2Field4 = meta.FieldList[8];
Assert.AreEqual <int>(FtStandardDataType.Integer, sequence2Field4.DataType);
FtMetaField sequence3Field1 = meta.FieldList[9];
Assert.AreEqual <int>(FtStandardDataType.Boolean, sequence3Field1.DataType);
FtMetaField sequence4Field1 = meta.FieldList[10];
Assert.AreEqual <int>(FtStandardDataType.Float, sequence4Field1.DataType);
FtMetaField sequence4Field2 = meta.FieldList[11];
Assert.AreEqual <int>(FtStandardDataType.Decimal, sequence4Field2.DataType);
Assert.AreEqual <int>(5, meta.SequenceList.Count);
FtMetaSequence rootSequence = meta.SequenceList[0];
Assert.AreEqual <bool>(true, rootSequence.Root);
Assert.AreEqual <string>(RootSequenceName, rootSequence.Name);
Assert.AreEqual <int>(3, rootSequence.ItemList.Count);
FtMetaSequence sequence1 = meta.SequenceList[1];
Assert.AreEqual <bool>(false, sequence1.Root);
Assert.AreEqual <string>(Sequence1Name, sequence1.Name);
Assert.AreEqual <int>(2, sequence1.ItemList.Count);
FtMetaSequence sequence2 = meta.SequenceList[2];
Assert.AreEqual <bool>(false, sequence2.Root);
Assert.AreEqual <string>(Sequence2Name, sequence2.Name);
Assert.AreEqual <int>(4, sequence2.ItemList.Count);
FtMetaSequence sequence3 = meta.SequenceList[3];
Assert.AreEqual <bool>(false, sequence3.Root);
Assert.AreEqual <string>(Sequence3Name, sequence3.Name);
Assert.AreEqual <int>(1, sequence3.ItemList.Count);
FtMetaSequence sequence4 = meta.SequenceList[4];
Assert.AreEqual <bool>(false, sequence4.Root);
Assert.AreEqual <string>(Sequence4Name, sequence4.Name);
Assert.AreEqual <int>(2, sequence4.ItemList.Count);
Assert.AreEqual <FtMetaField>(rootSequence.ItemList[0].Field, rootField1);
FtMetaSequenceItem rootItem2 = rootSequence.ItemList[1];
Assert.AreEqual <FtMetaField>(rootItem2.Field, rootField2);
Assert.AreEqual <FtMetaField>(rootSequence.ItemList[2].Field, rootField3);
Assert.AreEqual <FtMetaField>(sequence1.ItemList[0].Field, sequence1Field1);
FtMetaSequenceItem sequence1Item2 = sequence1.ItemList[1];
Assert.AreEqual <FtMetaField>(sequence1Item2.Field, sequence1Field2);
Assert.AreEqual <FtMetaField>(sequence2.ItemList[0].Field, sequence2Field1);
Assert.AreEqual <FtMetaField>(sequence2.ItemList[1].Field, sequence2Field2);
FtMetaSequenceItem sequence2Item3 = sequence2.ItemList[2];
Assert.AreEqual <FtMetaField>(sequence2Item3.Field, sequence2Field3);
Assert.AreEqual <FtMetaField>(sequence2.ItemList[3].Field, sequence2Field4);
Assert.AreEqual <FtMetaField>(sequence3.ItemList[0].Field, sequence3Field1);
Assert.AreEqual <FtMetaField>(sequence4.ItemList[0].Field, sequence4Field1);
Assert.AreEqual <FtMetaField>(sequence4.ItemList[1].Field, sequence4Field2);
FtExactIntegerMetaSequenceRedirect rootRedirect1 = rootItem2.RedirectList[0] as FtExactIntegerMetaSequenceRedirect;
Assert.AreEqual <int>(FtStandardSequenceRedirectType.ExactInteger, ((FtMetaSequenceRedirect)rootRedirect1).Type);
Assert.AreEqual <FtSequenceInvokationDelay>(RootRedirect1InvokationDelay, rootRedirect1.InvokationDelay);
Assert.AreEqual <long>(RootRedirect1Value, rootRedirect1.Value);
Assert.AreEqual <FtMetaSequence>(sequence1, rootRedirect1.Sequence);
FtExactIntegerMetaSequenceRedirect rootRedirect2 = rootItem2.RedirectList[1] as FtExactIntegerMetaSequenceRedirect;
Assert.AreEqual <int>(FtStandardSequenceRedirectType.ExactInteger, ((FtMetaSequenceRedirect)rootRedirect2).Type);
Assert.AreEqual <FtSequenceInvokationDelay>(RootRedirect2InvokationDelay, rootRedirect2.InvokationDelay);
Assert.AreEqual <long>(RootRedirect2Value, rootRedirect2.Value);
Assert.AreEqual <FtMetaSequence>(sequence2, rootRedirect2.Sequence);
FtExactIntegerMetaSequenceRedirect rootRedirect3 = rootItem2.RedirectList[2] as FtExactIntegerMetaSequenceRedirect;
Assert.AreEqual <int>(FtStandardSequenceRedirectType.ExactInteger, ((FtMetaSequenceRedirect)rootRedirect3).Type);
Assert.AreEqual <FtSequenceInvokationDelay>(RootRedirect3InvokationDelay, rootRedirect3.InvokationDelay);
Assert.AreEqual <long>(RootRedirect3Value, rootRedirect3.Value);
Assert.AreEqual <FtMetaSequence>(sequence3, rootRedirect3.Sequence);
FtNullMetaSequenceRedirect sequence1Redirect1 = sequence1Item2.RedirectList[0] as FtNullMetaSequenceRedirect;
Assert.AreEqual <int>(FtStandardSequenceRedirectType.Null, ((FtMetaSequenceRedirect)sequence1Redirect1).Type);
Assert.AreEqual <FtSequenceInvokationDelay>(Sequence1Redirect1InvokationDelay, sequence1Redirect1.InvokationDelay);
Assert.AreEqual <FtMetaSequence>(sequence4, sequence1Redirect1.Sequence);
FtCaseInsensitiveStringMetaSequenceRedirect sequence2Redirect1 = sequence2Item3.RedirectList[0] as FtCaseInsensitiveStringMetaSequenceRedirect;
Assert.AreEqual <int>(FtStandardSequenceRedirectType.CaseInsensitiveString, ((FtMetaSequenceRedirect)sequence2Redirect1).Type);
Assert.AreEqual <FtSequenceInvokationDelay>(Sequence2Redirect1InvokationDelay, sequence2Redirect1.InvokationDelay);
Assert.AreEqual <FtMetaSequence>(sequence4, sequence2Redirect1.Sequence);
}
internal protected virtual bool ResolveItemsTo(FtMetaSequence sequence, FtMetaFieldList fieldList, FtMetaSequenceList sequenceList, out string errorDescription)
{
ItemSorter.Rec[] sorterRecArray = new ItemSorter.Rec[itemList.Count + fieldIndices.Length];
SequenceItemReadElement[] sortedItemElements;
for (int i = 0; i < itemList.Count; i++)
{
SequenceItemReadElement itemElement = itemList[i];
sorterRecArray[i].Target = itemElement;
sorterRecArray[i].Implicit = i;
sorterRecArray[i].Explicit = itemElement.ExplicitIndex;
}
int elementallyDefinedItemCount = itemList.Count;
for (int i = 0; i < fieldIndices.Length; i++)
{
SequenceItemReadElement itemElement = new SequenceItemReadElement();
// Add FieldIndex to element as if it were read from an attribute.
int fieldIndex = fieldIndices[i];
string attributeName = SequenceItemPropertyIdFormatter.ToAttributeName(FtMetaSequenceItem.PropertyId.FieldIndex);
string attributeValue = FtStandardText.Get(fieldIndex);
if (!itemElement.TryAddOrIgnoreAttribute(attributeName, attributeValue, out errorDescription))
{
throw FtInternalException.Create(InternalError.SequenceReadElement_ResolveItemsTo_TryAddOrIgnoreAttribute, errorDescription); // program error
}
else
{
int implicitIndex = elementallyDefinedItemCount + i;
sorterRecArray[implicitIndex].Target = itemElement;
sorterRecArray[implicitIndex].Implicit = implicitIndex;
sorterRecArray[implicitIndex].Explicit = -1;
}
}
int duplicateExplicitIndex;
if (!ItemSorter.TrySort(sorterRecArray, out sortedItemElements, out duplicateExplicitIndex))
{
errorDescription = string.Format(Properties.Resources.SequenceReadElement_ResolveItemsTo_DuplicateExplicitIndex, duplicateExplicitIndex);
return(false);
}
else
{
errorDescription = "";
bool result = true;
for (int i = 0; i < sortedItemElements.Length; i++)
{
SequenceItemReadElement itemElement = sortedItemElements[i];
FtMetaSequenceItem item = sequence.ItemList.New();
if (!itemElement.ResolveTo(item, fieldList, sequenceList, out errorDescription))
{
result = false;
break;
}
}
return(result);
}
}
