public static List<string> GetListFromLexRecord(LexRecord lexRecord, int contentType)
        {
            List<string> outList = new List<string>();
            switch (contentType)

            {
                case 2:
                    outList = lexRecord.GetSpellingVars();
                    break;
                case 5:
                    outList = lexRecord.GetVariants();
                    break;
                case 6:
                    outList = lexRecord.GetNominalizations();
                    break;
                case 7:
                    outList = lexRecord.GetAbbreviations();
                    break;
                case 8:
                    outList = lexRecord.GetAcronyms();
                    break;
            }

            return outList;
        }
        public static void SetItemInListInLexRecordAt(LexRecord lexRecord, int contentType, string item, int index)
        {
            switch (contentType)

            {
                case 2:
                    lexRecord.GetSpellingVars()[index] = item;
                    break;
                case 5:
                    lexRecord.GetVariants()[index] = item;
                    break;
                case 6:
                    lexRecord.GetNominalizations()[index] = item;
                    break;
                case 7:
                    lexRecord.GetAbbreviations()[index] = item;
                    break;
                case 8:
                    lexRecord.GetAcronyms()[index] = item;
                    break;
            }
        }
Example #3
0
        private static void GetLexRecord(Node node, LexRecord lexRecord, CatEntry catEntry)


        {
            if (node.NodeType == XmlNodeType.Element)

            {
                if (node.Name.Equals("base"))

                {
                    lexRecord.SetBase(getValue(node));
                }
                else if (node.Name.Equals("eui"))

                {
                    lexRecord.SetEui(getValue(node));
                }
                else if (node.Name.Equals("cat"))
                {
                    lexRecord.SetCat(getValue(node));
                }
                else if (node.Name.Equals("spellingVars"))

                {
                    lexRecord.SetSpellingVar(getValue(node));
                }
                else if (node.Name.Equals("acronyms"))

                {
                    lexRecord.GetAcronyms().Add(getValue(node));
                }
                else if (node.Name.Equals("abbreviations"))

                {
                    lexRecord.GetAbbreviations().Add(getValue(node));
                }
                else if (node.Name.Equals("annotations"))

                {
                    lexRecord.GetAnnotations().Add(getValue(node));
                }
                else if (node.Name.Equals("signature"))

                {
                    lexRecord.SetSignature(getValue(node));
                }
                else if (node.Name.Equals("verbEntry"))

                {
                    catEntry = getVerbValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("auxEntry"))

                {
                    catEntry = getAuxValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("modalEntry"))

                {
                    catEntry = getModalValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("nounEntry"))

                {
                    catEntry = getNounValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("pronEntry"))

                {
                    catEntry = getPronValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("adjEntry"))

                {
                    catEntry = getAdjValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("advEntry"))

                {
                    catEntry = getAdvValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
                else if (node.Name.Equals("detEntry"))

                {
                    catEntry = getDetValues(node);
                    lexRecord.SetCatEntry(catEntry);
                }
            }

            for (Node child = node.FirstChild; child != null; child = child.NextSibling)


            {
                GetLexRecord(child, lexRecord, catEntry);
            }
        }
        public static bool Check(LexRecord lexRecord, HashSet <string> notBaseFormSet)

        {
            bool          validFlag = true;
            List <string> abbList   = lexRecord.GetAbbreviations();
            string        abbCat    = lexRecord.GetCategory();

            for (int i = 0; i < abbList.Count; i++)

            {
                string abb = (string)abbList[i];

                int    index1 = abb.IndexOf("|", StringComparison.Ordinal);
                string abbCit = "";
                string abbEui = "";
                if (index1 > 0)

                {
                    abbCit = abb.Substring(0, index1);
                    abbEui = abb.Substring(index1 + 1);
                }
                else

                {
                    abbCit = abb;
                }

                string citCat = abbCit + "|" + abbCat;

                HashSet <string> euisByCitCat = CrossCheckDupLexRecords.GetEuisByCitCat(citCat);

                if (euisByCitCat == null)

                {
                    if (abbEui.Length > 0)

                    {
                        abbList[i] = abbCit;

                        validFlag = false;
                        ErrMsgUtilLexicon.AddContentErrMsg(4, 3, abb + " - None", lexRecord);
                    }
                    else

                    {
                        validFlag = false;

                        if (!notBaseFormSet.Contains(citCat))

                        {
                            ErrMsgUtilLexicon.AddContentErrMsg(4, 4, abb + " - New", lexRecord);
                        }
                    }
                }
                else if (euisByCitCat.Count == 1)

                {
                    List <string> euiList = new List <string>(euisByCitCat);
                    string        newEui  = (string)euiList[0];
                    if (abbEui.Length > 0)

                    {
                        if (euisByCitCat.Contains(abbEui) != true)

                        {
                            validFlag = false;
                            ErrMsgUtilLexicon.AddContentErrMsg(4, 6, abb + " - " + newEui, lexRecord);
                        }
                    }
                    else

                    {
                        string newAbb = abb + "|" + newEui;
                        abbList[i] = newAbb;

                        validFlag = false;
                        ErrMsgUtilLexicon.AddContentErrMsg(4, 5, abb + " - " + newEui, lexRecord);
                    }
                }
                else

                {
                    List <string> euiList = new List <string>(euisByCitCat);
                    if (abbEui.Length > 0)

                    {
                        if (euisByCitCat.Contains(abbEui) != true)

                        {
                            validFlag = false;
                            ErrMsgUtilLexicon.AddContentErrMsg(4, 8, abb + " - " + euiList, lexRecord);
                        }
                    }
                    else

                    {
                        validFlag = false;
                        ErrMsgUtilLexicon.AddContentErrMsg(4, 7, abb + " - " + euiList, lexRecord);
                    }
                }
            }


            return(validFlag);
        }