public virtual List <string> GetSpellingVars(string separator) { List <string> spellingVars = new List <string>(); if (lexRecordObjs_ != null) { for (int i = 0; i < lexRecordObjs_.Count; i++) { LexRecord temp = (LexRecord)lexRecordObjs_[i]; string eui = temp.GetEui(); string category = temp.GetCategory(); spellingVars.Add(temp.GetBase() + separator + eui + separator + category); List <string> tempSpellVars = temp.GetSpellingVars(); for (int j = 0; j < tempSpellVars.Count; j++) { string tempSpellVar = (string)tempSpellVars[j]; spellingVars.Add(tempSpellVar + separator + eui + separator + category); } } } return(spellingVars); }
public static void AddContentErrMsg(int contentType, int errType, string curItem, LexRecord lexRecord, string[][] errTypeStrs, int[] errTypeNos, bool crossRefFlag) { string contentTypeStr = LexRecordUtil.GetContentTypeStr(contentType); if (crossRefFlag == true) { contentTypeStr = LexRecordUtil.GetCrossRefTypeStr(contentType); } string errTypeStr = GetErrTypeStr(errType, errTypeStrs); string errFixStr = GetErrFixStr(errType, errTypeStrs); string errMsg = "** Content Err in " + contentTypeStr + " - " + errTypeStr + " (" + curItem + "): @ [" + LexRecordUtil.GetLexRecordInfo(lexRecord) + "]" + errFixStr + GlobalVars.LS_STR; if (errType == 9) { errMsg = errMsg + "=> Add EUI (" + lexRecord.GetEui() + ") to irregExcetions.data if this Err is an OK exception." + GlobalVars.LS_STR; } errMsg_ += errMsg; AddErrTypeNo(errType, errTypeNos); }
public static string GetLexRecordInfo(LexRecord lexRecord) { string eui = lexRecord.GetEui(); string cat = lexRecord.GetCategory(); string @base = lexRecord.GetBase(); string info = eui + "|" + @base + "|" + cat; return info; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static void CheckLexRecords(java.util.Vector<gov.nih.nlm.nls.lexCheck.Lib.LexRecord> lexRecords, java.io.BufferedWriter out, boolean verbose, java.util.HashSet<String> irregExpEuiList) throws Exception public static void CheckLexRecords(List <LexRecord> lexRecords, System.IO.StreamWriter @out, bool verbose, HashSet <string> irregExpEuiList) { int errRecordNo = 0; int okRecordNo = 0; int recSize = lexRecords.Count; if (verbose == true) { Console.WriteLine("===== Check LexRecord Contents ====="); } if (lexRecords.Count > 0) { for (int i = 0; i < recSize; i++) { LexRecord lexRecord = (LexRecord)lexRecords[i]; if (verbose == true) { Console.WriteLine("--- Checking: " + lexRecord.GetEui() + " ---"); } if (!StaticCheckLexRecord(lexRecord, irregExpEuiList)) { Console.WriteLine(ErrMsgUtil.GetErrMsg()); errRecordNo++; } else { okRecordNo++; } if (@out != null) { string text = lexRecord.GetText(); @out.Write(text); } } } Console.WriteLine("----- Total lexRecords checked: " + recSize); Console.WriteLine("--- lexRecord has no error: " + okRecordNo); Console.WriteLine("--- lexRecord has error(s): " + errRecordNo); Console.WriteLine("----- content error type stats -----"); Console.WriteLine(ErrMsgUtilLexRecord.GetErrStats()); }
public LexRecordNomObj(LexRecord lexRecord) { if (lexRecord != null) { base_ = lexRecord.GetBase(); eui_ = lexRecord.GetEui(); category_ = lexRecord.GetCategory(); nominalizations_ = lexRecord.GetNominalizations(); } }
private static bool CheckIllegalEui(LexRecord lexRecord) { bool validFlag = true; string eui = lexRecord.GetEui(); if (eui.Equals("E0000000") == true) { validFlag = false; ErrMsgUtilLexRecord.AddContentErrMsg(4, 1, eui, lexRecord); } return(validFlag); }
public virtual List <string> GetBases(string separator) { List <string> bases = new List <string>(); if (lexRecordObjs_ != null) { for (int i = 0; i < lexRecordObjs_.Count; i++) { LexRecord temp = (LexRecord)lexRecordObjs_[i]; bases.Add(temp.GetBase() + separator + temp.GetEui() + separator + temp.GetCategory()); } } return(bases); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static boolean Check(java.util.Vector<gov.nih.nlm.nls.lexCheck.Lib.LexRecord> lexRecords) throws java.io.IOException public static bool Check(List <LexRecord> lexRecords) { bool validFlag = true; HashSet <string> euiList = new HashSet <string>(); int recSize = lexRecords.Count; for (int i = 0; i < recSize; i++) { LexRecord lexRecord = (LexRecord)lexRecords[i]; string eui = lexRecord.GetEui(); if (!euiList.Add(eui)) { validFlag = false; ErrMsgUtilLexicon.AddContentErrMsg(1, 1, eui, lexRecord); } } return(validFlag); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static boolean Check(java.util.Vector<gov.nih.nlm.nls.lexCheck.Lib.LexRecord> lexRecords, java.util.Hashtable<String, java.util.HashSet<String>> dupRecExpList, java.io.BufferedWriter out, boolean verbose) throws java.io.IOException public static bool Check(List <LexRecord> lexRecords, Dictionary <string, HashSet <string> > dupRecExpList, System.IO.StreamWriter @out, bool verbose) { bool validFlag = true; int recSize = lexRecords.Count; for (int i = 0; i < recSize; i++) { LexRecord lexRecord = (LexRecord)lexRecords[i]; string cit = lexRecord.GetBase(); string cat = lexRecord.GetCategory(); string eui = lexRecord.GetEui(); string citCat = cit + "|" + cat; bool dupFlag = AddToCitCatEuisTable(citCat, eui); validFlag = (validFlag) && (dupFlag); if (verbose == true) { if ((i % 100000 == 0) && (i > 0)) { Console.WriteLine("- Loaded " + i + " lexRecords to table"); } } } if (verbose == true) { Console.WriteLine("- Complete loaded " + recSize + " lexRecords to hash table for dupRec check"); } if (!validFlag) { IEnumerator <string> keys = citCatEuisTable_.Keys.GetEnumerator(); while (keys.MoveNext() == true) { string key = (string)keys.Current; HashSet <string> euis = (HashSet <string>)citCatEuisTable_[key]; bool dupFlag = false; if (euis.Count > 1) { IEnumerator <string> it = euis.GetEnumerator(); while (it.MoveNext() == true) { string eui = (string)it.Current; HashSet <string> dupRecExpEuis = (HashSet <string>)dupRecExpList[key]; if ((dupRecExpEuis == null) || (!dupRecExpEuis.Contains(eui))) { dupFlag = true; } } if (dupFlag == true) { string errMsg = key; IEnumerator <string> it2 = euis.GetEnumerator(); while (it2.MoveNext() == true) { errMsg = errMsg + "|" + (string)it2.Current; } @out.Write(errMsg + "|"); @out.WriteLine(); ErrMsgUtilLexicon.AddContentErrMsg(2, 2, errMsg); } } } } return(validFlag); }
/** * make a WordElement from a lexical record. Currently just specifies basic * params and inflections Should do more in the future! * * @param record * @return */ private WordElement makeWord(LexRecord record) // LexRecord { // get basic data String baseForm = record.GetBase(); LexicalCategory category = record.GetSimpleNLGCategory(record); String id = record.GetEui(); // create word class WordElement wordElement = new WordElement(baseForm, category, id); // now add type information switch (category.GetLexicalCategory()) { case LexicalCategory.LexicalCategoryEnum.ADJECTIVE: addAdjectiveInfo(wordElement, record.GetCatEntry().GetAdjEntry()); break; case LexicalCategory.LexicalCategoryEnum.ADVERB: addAdverbInfo(wordElement, record.GetCatEntry().GetAdvEntry()); break; case LexicalCategory.LexicalCategoryEnum.NOUN: addNounInfo(wordElement, record.GetCatEntry().GetNounEntry()); break; case LexicalCategory.LexicalCategoryEnum.VERB: addVerbInfo(wordElement, record.GetCatEntry().GetVerbEntry()); break; // ignore closed class words } Inflection?defaultInfl = wordElement.getDefaultInflectionalVariant(); // now add inflected forms // if (keepStandardInflections || !standardInflections(record, // category)) { foreach (InflVar inflection in record.GetInflVarsAndAgreements().GetInflValues()) { String simplenlgInflection = getSimplenlgInflection(inflection .GetInflection()); if (simplenlgInflection != null) { String inflectedForm = inflection.GetVar(); Inflection?inflType = Inflection.REGULAR.getInflCode(inflection.GetType()); // store all inflectional variants, except for regular ones // unless explicitly set if (inflType != null && !(Inflection.REGULAR == inflType && !keepStandardInflections)) { wordElement.addInflectionalVariant((Inflection)inflType, simplenlgInflection, inflectedForm); } // if the infl variant is the default, also set this feature on // the word if (defaultInfl == null || (defaultInfl.Equals(inflType) && !(Inflection.REGULAR.Equals(inflType) && !keepStandardInflections))) { wordElement.setFeature(simplenlgInflection, inflectedForm); } // wordElement // .setFeature(simplenlgInflection, inflection.GetVar()); } } // } // add acronym info addAcronymInfo(wordElement, record); // now add spelling variants addSpellingVariants(wordElement, record); return(wordElement); }
private static bool CheckIrreg(LexRecord lexRecord, HashSet <string> irregExpEuiList) { bool validFlag = true; List <string> variants = lexRecord.GetVariants(); string citation = lexRecord.GetBase(); List <string> svList = lexRecord.GetSpellingVars(); HashSet <string> baseList = new HashSet <string>(svList); baseList.Add(citation); HashSet <string> irregBases = new HashSet <string>(); string variant; for (System.Collections.IEnumerator localIterator = variants.GetEnumerator(); localIterator.MoveNext();) { variant = (string)localIterator.Current; if ((variant.StartsWith("irreg|")) || (variant.StartsWith("group(irreg|"))) { string irregBase = GetIrregBase(variant); if (!baseList.Contains(irregBase)) { validFlag = false; ErrMsgUtilLexRecord.AddContentErrMsg(5, 8, variant, lexRecord); } else { irregBases.Add(irregBase); } } } if (!validFlag) { return(validFlag); } if (irregBases.Count > 0) { string eui = lexRecord.GetEui(); if ((baseList.Count != irregBases.Count) && (!irregExpEuiList.Contains(eui))) { validFlag = false; foreach (string @base in baseList) { if (!irregBases.Contains(@base)) { ErrMsgUtilLexRecord.AddContentErrMsg(5, 9, @base, lexRecord); } } } } return(validFlag); }