private bool ResolveInvokationDelay(FtMetaSequenceRedirect redirect, out string errorDescription)
{
errorDescription = "";
bool result = true;
string attributeValue;
if (!attributeDictionary.TryGetValue(FtMetaSequenceRedirect.PropertyId.InvokationDelay, out attributeValue))
{
redirect.InvokationDelay = MetaSerializationDefaults.SequenceRedirect.InvokationDelay;
}
else
{
FtSequenceInvokationDelay propertyValue;
if (SequenceInvokationDelayFormatter.TryParseAttributeValue(attributeValue, out propertyValue))
{
redirect.InvokationDelay = propertyValue;
}
else
{
errorDescription = string.Format(Properties.Resources.SequenceRedirectReadElement_ResolveInvokationDelay_Invalid, attributeValue);
result = false;
}
}
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);
}
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);
}
}
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);
}
}
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 override void LoadMeta(FtMetaSequenceRedirect metaSequenceRedirect, FtMetaSequenceList metaSequenceList, FtSequenceList sequenceList)
{
base.LoadMeta(metaSequenceRedirect, metaSequenceList, sequenceList);
}
