/// <summary>
/// Validate Lexicon according to TTS phone set and pos set or lexical attribute schema.
/// </summary>
/// <param name="ttsPhoneSet">TTS phone set.</param>
/// <param name="ttsPosSet">TTS POS set.</param>
/// <param name="attributeSchema">Lexical attribute Schema.</param>
private void Validate(TtsPhoneSet ttsPhoneSet, TtsPosSet ttsPosSet,
LexicalAttributeSchema attributeSchema)
{
Debug.Assert(ttsPhoneSet != null);
Debug.Assert(ttsPosSet != null || attributeSchema != null);
bool dependentDataValid = true;
ttsPhoneSet.Validate();
if (ttsPhoneSet.ErrorSet.Contains(ErrorSeverity.MustFix))
{
ErrorSet.Add(LexiconError.InvalidDependentData, "Phone set");
dependentDataValid = false;
}
if (ttsPosSet != null)
{
ttsPosSet.Validate();
if (ttsPosSet.ErrorSet.Contains(ErrorSeverity.MustFix))
{
ErrorSet.Add(LexiconError.InvalidDependentData, "POS set");
dependentDataValid = false;
}
}
if (attributeSchema != null)
{
attributeSchema.Validate();
if (attributeSchema.ErrorSet.Contains(ErrorSeverity.MustFix))
{
ErrorSet.Add(LexiconError.InvalidDependentData, "Lexical Attribute Schema");
dependentDataValid = false;
}
}
if (dependentDataValid)
{
bool containValidItem = false;
foreach (LexicalItem lexItem in Items.Values)
{
ErrorSet errorSet = lexItem.Validate(ttsPhoneSet, ttsPosSet, attributeSchema);
ErrorSet.Merge(errorSet);
containValidItem = containValidItem || lexItem.Valid;
}
if (!containValidItem)
{
ErrorSet.Add(LexiconError.EmptyLexicon);
}
}
validated = true;
}
/// <summary>
/// Parse XML document for Lexicon Schema File path.
/// </summary>
/// <param name="dom">XML configuration document.</param>
/// <param name="nsmgr">Namespace.</param>
private void ParseLexiconSchema(XmlDocument dom, XmlNamespaceManager nsmgr)
{
LexiconSchemaFile = ParseFilePath(dom, nsmgr, LexiconSchemaFileItem);
if (!Helper.FileValidExists(LexiconSchemaFile))
{
throw new FileNotFoundException(
string.Format(CultureInfo.InvariantCulture,
"Lexicon schema file \"{0}\" not found", LexiconSchemaFile));
}
LexicalAttributeSchema attributeSchema = new LexicalAttributeSchema(FontLanguage);
attributeSchema.Load(LexiconSchemaFile);
attributeSchema.Validate();
if (attributeSchema.ErrorSet.Contains(ErrorSeverity.MustFix))
{
attributeSchema.ErrorSet.Export(Console.Error);
throw new InvalidDataException(
string.Format(CultureInfo.InvariantCulture,
"Please fix the error of lexicon schema file \"{0}\"", LexiconSchemaFile));
}
PosSet = TtsPosSet.LoadFromSchema(LexiconSchemaFile);
}
/// <summary>
/// Load Lexicon Attribute Schema Data object.
/// </summary>
/// <param name="errorSet">ErrorSet.</param>
/// <returns>Lexicon Attribute Schema Data object.</returns>
internal override object LoadDataObject(ErrorSet errorSet)
{
if (errorSet == null)
{
throw new ArgumentNullException("errorSet");
}
LexicalAttributeSchema schema = new LexicalAttributeSchema();
schema.Load(this.Path);
schema.Validate();
errorSet.Merge(schema.ErrorSet);
if (schema.ErrorSet.Contains(ErrorSeverity.MustFix))
{
schema = null;
}
return schema;
}
