// properties
private bool ResolveName(FtMetaSequence sequence, FtMetaSequenceList existingSequences, out string errorDescription)
{
errorDescription = "";
bool result = true;
string attributeValue;
if (!attributeDictionary.TryGetValue(FtMetaSequence.PropertyId.Name, out attributeValue))
{
errorDescription = Properties.Resources.SequenceReadElement_ResolveName_Missing;
result = false;
}
else
{
int existingNameIdx = existingSequences.IndexOfName(attributeValue);
if (existingNameIdx >= 0 && existingNameIdx < existingSequences.Count - 1) // sequence is last in existing list, so ignore that
{
errorDescription = string.Format(Properties.Resources.SequenceReadElement_ResolveName_Duplicate, attributeValue);
result = false;
}
else
{
sequence.Name = attributeValue;
}
}
return(result);
}
// properties
private bool ResolveSequenceName(FtMetaSequenceRedirect redirect, FtMetaSequenceList sequenceList, out string errorDescription)
{
bool result = false;
string attributeValue;
if (!attributeDictionary.TryGetValue(FtMetaSequenceRedirect.PropertyId.SequenceName, out attributeValue))
{
errorDescription = string.Format(Properties.Resources.SequenceRedirectReadElement_ResolveSequenceName_Missing, FtStandardSequenceRedirectType.ToName(redirectType));
}
else
{
string sequenceName = attributeValue.Trim();
int sequenceIdx = sequenceList.IndexOfName(sequenceName);
if (sequenceIdx < 0)
{
errorDescription = string.Format(Properties.Resources.SequenceRedirectReadElement_ResolveSequenceName_NotExist, sequenceName, FtStandardSequenceRedirectType.ToName(redirectType));
}
else
{
redirect.Sequence = sequenceList[sequenceIdx];
errorDescription = "";
result = true;
}
}
return(result);
}
internal void LoadMetaSequenceRedirects(FtMetaSequence metaSequence, FtMetaSequenceList metaSequenceList, FtSequenceList sequenceList)
{
for (int i = 0; i < itemList.Count; i++)
{
// Note that Sequence Items are in same order as MetaSequence Items
itemList[i].LoadMetaSequenceRedirects(metaSequence.ItemList[i], metaSequenceList, sequenceList);
}
}
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);
}
}
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);
}
}
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);
}
protected virtual bool ResolveProperties(FtMetaSequenceRedirect redirect, FtMetaSequenceList sequenceList, out string errorDescription)
{
errorDescription = "";
bool result = true;
redirectType = redirect.Type; // may have been set to field default
foreach (FtMetaSequenceRedirect.PropertyId id in Enum.GetValues(typeof(FtMetaSequenceRedirect.PropertyId)))
{
switch (id)
{
case FtMetaSequenceRedirect.PropertyId.Index:
case FtMetaSequenceRedirect.PropertyId.Type:
// already handled in TryAddOrIgnoreAttribute
break;
case FtMetaSequenceRedirect.PropertyId.SequenceName:
result = ResolveSequenceName(redirect, sequenceList, out errorDescription);
break;
case FtMetaSequenceRedirect.PropertyId.InvokationDelay:
result = ResolveInvokationDelay(redirect, out errorDescription);
break;
case FtMetaSequenceRedirect.PropertyId.Value:
switch (redirectType)
{
case FtStandardSequenceRedirectType.Boolean:
result = ResolveBooleanValue(redirect as FtBooleanMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.CaseInsensitiveString:
result = ResolveCaseInsensitiveStringValue(redirect as FtCaseInsensitiveStringMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.Date:
result = ResolveDateValue(redirect as FtDateMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.ExactDateTime:
result = ResolveExactDateTimeValue(redirect as FtExactDateTimeMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.ExactDecimal:
result = ResolveExactDecimalValue(redirect as FtExactDecimalMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.ExactFloat:
result = ResolveExactFloatValue(redirect as FtExactFloatMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.ExactInteger:
result = ResolveExactIntegerValue(redirect as FtExactIntegerMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.ExactString:
result = ResolveExactStringValue(redirect as FtExactStringMetaSequenceRedirect, out errorDescription);
break;
case FtStandardSequenceRedirectType.Null:
// does not have Value
result = true;
break;
default:
throw FtInternalException.Create(InternalError.SequenceRedirectReadElement_ResolveProperties_ValueUnsupportedRedirectType,
id.ToString() + "," + redirectType.ToString());
}
break;
default:
throw FtInternalException.Create(InternalError.SequenceRedirectReadElement_ResolveProperties_UnsupportedPropertyId, id.ToString());
}
if (!result)
{
break;
}
}
return(result);
}
internal protected virtual bool ResolveTo(FtMetaSequenceRedirect redirect, FtMetaSequenceList sequenceList, out string errorDescription)
{
return(ResolveProperties(redirect, sequenceList, out errorDescription));
}
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 protected override void LoadMeta(FtMetaSequenceRedirect metaSequenceRedirect, FtMetaSequenceList metaSequenceList, FtSequenceList sequenceList)
{
base.LoadMeta(metaSequenceRedirect, metaSequenceList, sequenceList);
}
