/// <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(); }
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(); }
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; }