internal protected virtual bool ResolvePropertiesTo(FtMetaSequence sequence, FtMetaFieldList fieldList, FtMetaSequenceList existingSequences, out string errorDescription)
{
errorDescription = "";
bool result = false;
foreach (FtMetaSequence.PropertyId id in Enum.GetValues(typeof(FtMetaSequence.PropertyId)))
{
switch (id)
{
case FtMetaSequence.PropertyId.Name:
result = ResolveName(sequence, existingSequences, out errorDescription);
break;
case FtMetaSequence.PropertyId.Root:
result = ResolveRoot(sequence, out errorDescription);
break;
case FtMetaSequence.PropertyId.FieldIndices:
result = ResolveFieldIndices(sequence, fieldList, out errorDescription);
break;
default:
throw FtInternalException.Create(InternalError.SequenceReadElement_ResolvePropertiesTo_UnsupportedPropertyId, id.ToString());
}
if (!result)
{
break;
}
}
return(result);
}
private bool ResolveFieldIndices(FtMetaSequence sequence, FtMetaFieldList fieldList, out string errorDescription)
{
errorDescription = "";
bool result = true;
string attributeValue;
if (!attributeDictionary.TryGetValue(FtMetaSequence.PropertyId.FieldIndices, out attributeValue))
{
fieldIndices = new int[0];
}
else
{
int[] propertyValue;
if (FtCommaText.TryParse(attributeValue, out propertyValue, out errorDescription))
{
fieldIndices = propertyValue;
}
else
{
errorDescription = string.Format(Properties.Resources.SequenceReadElement_ResolveFieldIndices_Invalid, attributeValue);
result = false;
}
}
return(result);
}
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);
}
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));
}
}
internal void LoadMeta(FtMetaSequence metaSequence, FtMetaFieldList metaFieldList, FtFieldDefinitionList fieldDefinitionList)
{
name = metaSequence.Name;
root = metaSequence.Root;
for (int i = 0; i < metaSequence.ItemList.Count; i++)
{
FtSequenceItem Item = itemList.New();
Item.LoadMeta(metaSequence.ItemList[i], metaFieldList, fieldDefinitionList);
}
}
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);
}
}
