/// <summary>
/// Adds the character definition.
/// </summary>
private CharacterDefinition Add(IEnumerable <string> strReps, FeatureSymbol type, FeatureStruct fs)
{
string[] strRepsArray = strReps.ToArray();
string[] normalizedStrRepsArray = strRepsArray.Select(s => s.Normalize(NormalizationForm.FormD)).ToArray();
if (normalizedStrRepsArray.Any(s => _charDefLookup.ContainsKey(s)))
{
throw new ArgumentException(
"The table already contains a character definition with one of the specified representations.",
"strReps");
}
if (fs == null)
{
fs = FeatureStruct.New().Symbol(type).Feature(HCFeatureSystem.StrRep)
.EqualTo(normalizedStrRepsArray).Value;
}
else
{
fs.AddValue(HCFeatureSystem.Type, type);
fs.Freeze();
}
var cd = new CharacterDefinition(strRepsArray, fs);
_charDefs.Add(cd);
foreach (string rep in normalizedStrRepsArray)
{
_charDefLookup[rep] = cd;
}
cd.CharacterDefinitionTable = this;
return(cd);
}
private void AddNode(ShapeNode node, State <Shape, ShapeNode> state, string id)
{
Arc <Shape, ShapeNode> arc = state.Arcs.FirstOrDefault(a => node.Annotation.FeatureStruct.ValueEquals(a.Input.FeatureStruct));
ShapeNode nextNode = node.GetNext(n => _filter(n.Annotation));
State <Shape, ShapeNode> nextState;
if (arc != null)
{
nextState = arc.Target;
if (nextNode == node.List.End)
{
nextState.IsAccepting = true;
nextState.AcceptInfos.Add(new AcceptInfo <Shape, ShapeNode>(id, (shape, match) => true, _shapeCount));
}
}
else
{
nextState = nextNode == node.List.End ? _fsa.CreateAcceptingState(id, (shape, match) => true, _shapeCount) : _fsa.CreateState();
FeatureStruct condition = node.Annotation.FeatureStruct.Clone();
condition.Freeze();
state.Arcs.Add(condition, nextState);
}
if (nextNode != node.List.End)
{
AddNode(nextNode, nextState, id);
}
}
protected override int FreezeImpl()
{
int code = base.FreezeImpl();
_fs.Freeze();
code = code * 31 + _fs.GetFrozenHashCode();
return(code);
}
public NaturalClass(FeatureStruct fs)
{
if (!fs.IsFrozen)
{
fs.AddValue(HCFeatureSystem.Type, HCFeatureSystem.Segment);
fs.Freeze();
}
FeatureStruct = fs;
}
public SimpleContext(NaturalClass nc, IEnumerable<SymbolicFeatureValue> variables)
{
_nc = nc;
_variables = new ReadOnlyCollection<SymbolicFeatureValue>(variables.ToArray());
_fs = _nc.FeatureStruct.DeepClone();
foreach (SymbolicFeatureValue var in _variables)
_fs.AddValue(var.Feature, var);
_fs.Freeze();
}
public NaturalClass(FeatureStruct fs)
{
if (!fs.IsFrozen)
{
fs.AddValue(HCFeatureSystem.Type, HCFeatureSystem.Segment);
fs.Freeze();
}
FeatureStruct = fs;
}
private static void AddValue(SymbolCollection symbols, Symbol symbol, FeatureSymbol value)
{
FeatureStruct fs = symbol.FeatureStruct.DeepClone();
fs.AddValue(value.Feature, value);
fs.Freeze();
symbols.Remove(symbol);
symbols.Add(symbol.StrRep, fs, symbol.Overwrite);
}
public SimpleContext(NaturalClass nc, IEnumerable <SymbolicFeatureValue> variables)
{
_nc = nc;
_variables = new ReadOnlyCollection <SymbolicFeatureValue>(variables.ToArray());
_fs = _nc.FeatureStruct.Clone();
foreach (SymbolicFeatureValue var in _variables)
{
_fs.AddValue(var.Feature, var);
}
_fs.Freeze();
}
internal override State <TData, TOffset> GenerateNfa(Fst <TData, TOffset> fsa, State <TData, TOffset> startState, out bool hasVariables)
{
hasVariables = _fs.HasVariables;
FeatureStruct condition = _fs;
if (!_fs.IsFrozen)
{
condition = _fs.Clone();
condition.Freeze();
}
return(startState.Arcs.Add(condition, fsa.CreateState()));
}
public void Migrate(SegmentPool segmentPool, CogProject project)
{
Symbol symbol;
if (project.Segmenter.Consonants.TryGet("ħ", out symbol))
{
FeatureStruct fs = symbol.FeatureStruct.Clone();
fs.PriorityUnion(FeatureStruct.New(project.FeatureSystem)
.Symbol("pharyngeal")
.Symbol("fricative").Value);
fs.Freeze();
project.Segmenter.Consonants.Remove(symbol.StrRep);
project.Segmenter.Consonants.Add(symbol.StrRep, fs, symbol.Overwrite);
}
}
public static void AddSymbolBasedOn(this SymbolCollection symbols, string strRep, string basedOnStrRep, params FeatureSymbol[] values)
{
Symbol basedOnSymbol;
if (!symbols.Contains(strRep) &&
symbols.TryGetValue(basedOnStrRep, out basedOnSymbol))
{
FeatureStruct fs = basedOnSymbol.FeatureStruct.DeepClone();
foreach (FeatureSymbol value in values)
{
fs.AddValue(value.Feature, value);
}
fs.Freeze();
symbols.Add(strRep, fs);
}
}
public Segment Get(ShapeNode node)
{
if (node == null)
{
return(null);
}
return(_segments.GetOrAdd(node.StrRep(), s =>
{
FeatureStruct fs = node.Annotation.FeatureStruct.DeepClone();
fs.RemoveValue(CogFeatureSystem.OriginalStrRep);
fs.RemoveValue(CogFeatureSystem.SyllablePosition);
fs.Freeze();
return new Segment(fs);
}));
}
public void Freeze()
{
if (IsFrozen)
{
return;
}
IsFrozen = true;
_fs.Freeze();
if (_children != null)
{
_children.Freeze();
}
_hashCode = 23;
_hashCode = _hashCode * 31 + _fs.GetFrozenHashCode();
_hashCode = _hashCode * 31 + (_children == null ? 0 : _children.GetFrozenHashCode());
_hashCode = _hashCode * 31 + _optional.GetHashCode();
_hashCode = _hashCode * 31 + Range.GetHashCode();
}
protected override int FreezeImpl()
{
int code = 23;
_shape.Freeze();
code = code * 31 + _shape.GetFrozenHashCode();
_realizationalFS.Freeze();
code = code * 31 + _realizationalFS.GetFrozenHashCode();
foreach (Word nonHead in _nonHeads)
{
nonHead.Freeze();
code = code * 31 + nonHead.GetFrozenHashCode();
}
code = code * 31 + _stratum.GetHashCode();
code = code * 31 + (_rootAllomorph == null ? 0 : _rootAllomorph.GetHashCode());
code = code * 31 + _mrules.GetSequenceHashCode();
code = code * 31 + _isLastAppliedRuleFinal.GetHashCode();
return(code);
}
private bool TryLoadCompoundingRule(XElement compRuleElem, CharacterDefinitionTable defaultTable, out IMorphologicalRule mrule)
{
var compRuleID = (string) compRuleElem.Attribute("id");
var compRule = new CompoundingRule
{
Name = (string) compRuleElem.Element("Name"),
Blockable = (bool?) compRuleElem.Attribute("blockable") ?? true
};
var multApp = (string) compRuleElem.Attribute("multipleApplication");
if (!string.IsNullOrEmpty(multApp))
compRule.MaxApplicationCount = int.Parse(multApp);
var fs = new FeatureStruct();
var headRequiredPos = (string) compRuleElem.Attribute("headPartsOfSpeech");
if (!string.IsNullOrEmpty(headRequiredPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(headRequiredPos));
XElement headRequiredHeadFeatElem = compRuleElem.Element("HeadRequiredHeadFeatures");
if (headRequiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(headRequiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement headRequiredFootFeatElem = compRuleElem.Element("HeadRequiredFootFeatures");
if (headRequiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(headRequiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
compRule.HeadRequiredSyntacticFeatureStruct = fs;
fs = new FeatureStruct();
var nonHeadRequiredPos = (string) compRuleElem.Attribute("nonHeadPartsOfSpeech");
if (!string.IsNullOrEmpty(nonHeadRequiredPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(nonHeadRequiredPos));
XElement nonHeadRequiredHeadFeatElem = compRuleElem.Element("NonHeadRequiredHeadFeatures");
if (nonHeadRequiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(nonHeadRequiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement nonHeadRequiredFootFeatElem = compRuleElem.Element("NonHeadRequiredFootFeatures");
if (nonHeadRequiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(nonHeadRequiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
compRule.NonHeadRequiredSyntacticFeatureStruct = fs;
fs = new FeatureStruct();
var outPos = (string) compRuleElem.Attribute("outputPartOfSpeech");
if (!string.IsNullOrEmpty(outPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(outPos));
XElement outHeadFeatElem = compRuleElem.Element("OutputHeadFeatures");
if (outHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(outHeadFeatElem, _language.SyntacticFeatureSystem));
XElement outFootFeatElem = compRuleElem.Element("OutputFootFeatures");
if (outFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(outFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
compRule.OutSyntacticFeatureStruct = fs;
var obligHeadIDsStr = (string) compRuleElem.Attribute("outputObligatoryFeatures");
if (!string.IsNullOrEmpty(obligHeadIDsStr))
{
foreach (string obligHeadID in obligHeadIDsStr.Split(' '))
compRule.ObligatorySyntacticFeatures.Add(_language.SyntacticFeatureSystem.GetFeature(obligHeadID));
}
foreach (XElement subruleElem in compRuleElem.Elements("CompoundingSubrules").Elements("CompoundingSubrule").Where(IsActive))
{
try
{
compRule.Subrules.Add(LoadCompoundingSubrule(subruleElem, defaultTable));
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, compRuleID);
else
throw;
}
}
if (compRule.Subrules.Count > 0)
{
mrule = compRule;
return true;
}
mrule = null;
return false;
}
private bool TryLoadRealizationalRule(XElement realRuleElem, CharacterDefinitionTable defaultTable, out IMorphologicalRule mrule)
{
var realRuleID = (string) realRuleElem.Attribute("id");
var realRule = new RealizationalAffixProcessRule
{
Name = (string) realRuleElem.Element("Name"),
Gloss = (string) realRuleElem.Element("Gloss"),
Blockable = (bool?) realRuleElem.Attribute("blockable") ?? true
};
var fs = new FeatureStruct();
XElement requiredHeadFeatElem = realRuleElem.Element("RequiredHeadFeatures");
if (requiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(requiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement requiredFootFeatElem = realRuleElem.Element("RequiredFootFeatures");
if (requiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(requiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
realRule.RequiredSyntacticFeatureStruct = fs;
XElement realFeatElem = realRuleElem.Element("RealizationalFeatures");
if (realFeatElem != null)
realRule.RealizationalFeatureStruct = FeatureStruct.New().Feature(_headFeature).EqualTo(LoadFeatureStruct(realFeatElem, _language.SyntacticFeatureSystem)).Value;
LoadProperties(realRuleElem.Element("Properties"), realRule.Properties);
foreach (XElement subruleElem in realRuleElem.Elements("MorphologicalSubrules").Elements("MorphologicalSubrule").Where(IsActive))
{
try
{
AffixProcessAllomorph allomorph = LoadAffixProcessAllomorph(subruleElem, defaultTable);
realRule.Allomorphs.Add(allomorph);
_allomorphs[(string) subruleElem.Attribute("id")] = allomorph;
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, (string) realRuleElem.Attribute("id"));
else
throw;
}
}
if (realRule.Allomorphs.Count > 0)
{
_morphemes[realRuleID] = realRule;
mrule = realRule;
return true;
}
mrule = null;
return false;
}
private AffixProcessAllomorph LoadAffixProcessAllomorph(XElement msubruleElem, CharacterDefinitionTable defaultTable)
{
var allomorph = new AffixProcessAllomorph();
allomorph.Environments.AddRange(LoadAllomorphEnvironments(msubruleElem.Element("RequiredEnvironments"), ConstraintType.Require, defaultTable));
allomorph.Environments.AddRange(LoadAllomorphEnvironments(msubruleElem.Element("ExcludedEnvironments"), ConstraintType.Exclude, defaultTable));
var fs = new FeatureStruct();
XElement requiredHeadFeatElem = msubruleElem.Element("RequiredHeadFeatures");
if (requiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(requiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement requiredFootFeatElem = msubruleElem.Element("RequiredFootFeatures");
if (requiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(requiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
allomorph.RequiredSyntacticFeatureStruct = fs;
LoadProperties(msubruleElem.Element("Properties"), allomorph.Properties);
Dictionary<string, Tuple<string, SymbolicFeature>> variables = LoadVariables(msubruleElem.Element("VariableFeatures"));
XElement inputElem = msubruleElem.Element("MorphologicalInput");
Debug.Assert(inputElem != null);
allomorph.RequiredMprFeatures.UnionWith(LoadMprFeatures((string) inputElem.Attribute("requiredMPRFeatures")));
allomorph.ExcludedMprFeatures.UnionWith(LoadMprFeatures((string) inputElem.Attribute("excludedMPRFeatures")));
var partNames = new Dictionary<string, string>();
LoadMorphologicalLhs(inputElem, variables, partNames, allomorph.Lhs, defaultTable);
XElement outputElem = msubruleElem.Element("MorphologicalOutput");
Debug.Assert(outputElem != null);
allomorph.OutMprFeatures.UnionWith(LoadMprFeatures((string) outputElem.Attribute("MPRFeatures")));
allomorph.ReduplicationHint = GetReduplicationHint((string) outputElem.Attribute("redupMorphType"));
LoadMorphologicalRhs(outputElem, variables, partNames, allomorph.Rhs, defaultTable);
return allomorph;
}
private void LoadStemName(XElement stemNameElem)
{
var posIDs = (string) stemNameElem.Attribute("partsOfSpeech");
FeatureSymbol[] pos = posIDs.Split(' ').Select(id => _posFeature.PossibleSymbols[id]).ToArray();
var regions = new List<FeatureStruct>();
foreach (XElement regionElem in stemNameElem.Elements("Regions").Elements("Region"))
{
var fs = new FeatureStruct();
fs.AddValue(_posFeature, pos);
XElement headFeatElem = regionElem.Element("AssignedHeadFeatures");
if (headFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(headFeatElem, _language.SyntacticFeatureSystem));
XElement footFeatElem = regionElem.Element("AssignedFootFeatures");
if (footFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(footFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
regions.Add(fs);
}
var stemName = new StemName(regions) {Name = (string) stemNameElem.Element("Name")};
_language.StemNames.Add(stemName);
_stemNames[(string) stemNameElem.Attribute("id")] = stemName;
}
private bool TryLoadAffixProcessRule(XElement mruleElem, CharacterDefinitionTable defaultTable, out IMorphologicalRule mrule)
{
var id = (string) mruleElem.Attribute("id");
var affixProcessRule = new AffixProcessRule
{
Name = (string) mruleElem.Element("Name"),
Gloss = (string) mruleElem.Element("Gloss"),
Blockable = (bool?) mruleElem.Attribute("blockable") ?? true,
IsPartial = (bool?) mruleElem.Attribute("partial") ?? false
};
var multApp = (string) mruleElem.Attribute("multipleApplication");
if (!string.IsNullOrEmpty(multApp))
affixProcessRule.MaxApplicationCount = int.Parse(multApp);
var fs = new FeatureStruct();
var requiredPos = (string) mruleElem.Attribute("requiredPartsOfSpeech");
if (!string.IsNullOrEmpty(requiredPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(requiredPos));
XElement requiredHeadFeatElem = mruleElem.Element("RequiredHeadFeatures");
if (requiredHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(requiredHeadFeatElem, _language.SyntacticFeatureSystem));
XElement requiredFootFeatElem = mruleElem.Element("RequiredFootFeatures");
if (requiredFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(requiredFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
affixProcessRule.RequiredSyntacticFeatureStruct = fs;
fs = new FeatureStruct();
var outPos = (string) mruleElem.Attribute("outputPartOfSpeech");
if (!string.IsNullOrEmpty(outPos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(outPos));
XElement outHeadFeatElem = mruleElem.Element("OutputHeadFeatures");
if (outHeadFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(outHeadFeatElem, _language.SyntacticFeatureSystem));
XElement outFootFeatElem = mruleElem.Element("OutputFootFeatures");
if (outFootFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(outFootFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
affixProcessRule.OutSyntacticFeatureStruct = fs;
var obligHeadIDsStr = (string) mruleElem.Attribute("outputObligatoryFeatures");
if (!string.IsNullOrEmpty(obligHeadIDsStr))
{
foreach (string obligHeadID in obligHeadIDsStr.Split(' '))
affixProcessRule.ObligatorySyntacticFeatures.Add(_language.SyntacticFeatureSystem.GetFeature(obligHeadID));
}
var stemNameIDStr = (string) mruleElem.Attribute("requiredStemName");
if (!string.IsNullOrEmpty(stemNameIDStr))
affixProcessRule.RequiredStemName = _stemNames[stemNameIDStr];
LoadProperties(mruleElem.Element("Properties"), affixProcessRule.Properties);
foreach (XElement subruleElem in mruleElem.Elements("MorphologicalSubrules").Elements("MorphologicalSubrule").Where(IsActive))
{
try
{
AffixProcessAllomorph allomorph = LoadAffixProcessAllomorph(subruleElem, defaultTable);
affixProcessRule.Allomorphs.Add(allomorph);
_allomorphs[(string) subruleElem.Attribute("id")] = allomorph;
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, id);
else
throw;
}
}
if (affixProcessRule.Allomorphs.Count > 0)
{
_morphemes[id] = affixProcessRule;
mrule = affixProcessRule;
return true;
}
mrule = null;
return false;
}
public NaturalClass(string name, FeatureStruct fs)
: base(name)
{
_fs = fs;
_fs.Freeze();
}
public NaturalClass(string name, FeatureStruct fs)
: base(name)
{
_fs = fs;
_fs.Freeze();
}
private bool TryLoadLexEntry(XElement entryElem, CharacterDefinitionTable table, out LexEntry entry)
{
var id = (string) entryElem.Attribute("id");
entry = new LexEntry {Gloss = (string) entryElem.Element("Gloss")};
var fs = new FeatureStruct();
var pos = (string) entryElem.Attribute("partOfSpeech");
if (!string.IsNullOrEmpty(pos))
fs.AddValue(_posFeature, ParsePartsOfSpeech(pos));
XElement headFeatElem = entryElem.Element("AssignedHeadFeatures");
if (headFeatElem != null)
fs.AddValue(_headFeature, LoadFeatureStruct(headFeatElem, _language.SyntacticFeatureSystem));
XElement footFeatElem = entryElem.Element("AssignedFootFeatures");
if (footFeatElem != null)
fs.AddValue(_footFeature, LoadFeatureStruct(footFeatElem, _language.SyntacticFeatureSystem));
fs.Freeze();
entry.SyntacticFeatureStruct = fs;
entry.MprFeatures.UnionWith(LoadMprFeatures((string) entryElem.Attribute("ruleFeatures")));
var familyID = (string) entryElem.Attribute("family");
if (!string.IsNullOrEmpty(familyID))
{
LexFamily family = _families[familyID];
family.Entries.Add(entry);
}
entry.IsPartial = (bool?) entryElem.Attribute("partial") ?? false;
LoadProperties(entryElem.Element("Properties"), entry.Properties);
foreach (XElement alloElem in entryElem.Elements("Allomorphs").Elements("Allomorph").Where(IsActive))
{
try
{
RootAllomorph allomorph = LoadRootAllomorph(alloElem, table);
entry.Allomorphs.Add(allomorph);
_allomorphs[(string) alloElem.Attribute("id")] = allomorph;
}
catch (Exception e)
{
if (_errorHandler != null)
_errorHandler(e, id);
else
throw;
}
}
if (entry.Allomorphs.Count > 0)
{
_morphemes[id] = entry;
return true;
}
entry = null;
return false;
}
