示例#1
0
        private string TranslateRz(LetterToken token)
        {
            //{ "rz", "ж"},//перед и после k, p, t, ch	 ш,
            var result = "ж";

            if (token.NextToken != null &&
                (
                    token.NextToken.ForangeText == "k" ||
                    token.NextToken.ForangeText == "p" ||
                    token.NextToken.ForangeText == "t" ||
                    token.NextToken.ForangeText == "ch"))
            {
                result = "ш";
            }

            if (token.PrevToken != null && (
                    token.PrevToken.ForangeText == "k" ||
                    token.PrevToken.ForangeText == "p" ||
                    token.PrevToken.ForangeText == "t" ||
                    token.PrevToken.ForangeText == "ch"))
            {
                result = "ш";
            }

            return(result);
        }
示例#2
0
        private string TranslateJe(LetterToken token)
        {
            //{ "ję", "ен"},//в начале слова и после гласной перед b, p	 ем, в начале слова и после гласной в остальных случаях	 ен,
            //после согласной перед b, p	 ьем, после согласной в остальных случаях	 ьен
            var result = "ен";

            if (token.PrevToken == null || token.PrevToken != null &&
                vowels.Contains(token.PrevToken.ForangeText.Last()))
            {
                if (token.NextToken != null &&
                    (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
                {
                    result = "ем";
                }
                else
                {
                    result = "ен";
                }
            }

            if (token.PrevToken != null && consonants.Contains(token.PrevToken.ForangeText.Last()))
            {
                if (token.NextToken != null &&
                    (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
                {
                    result = "ьем";
                }
                else
                {
                    result = "ьен";
                }
            }

            return(result);
        }
示例#3
0
        private string TranslateIa(LetterToken token)
        {
            //{ "ią", "ён"}, //перед b, p	 ём, то же, после c	 иом, перед другими согласными	 ён, то же, после c	 ион
            var result = "ён";

            if (token.NextToken != null && (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
            {
                if (token.PrevToken != null && token.PrevToken.ForangeText == "c")
                {
                    result = "иом";
                }
                else
                {
                    result = "ём";
                }
            }
            if (token.NextToken != null && token.NextToken.ForangeText != "b" && token.NextToken.ForangeText != "p")
            {
                if (token.PrevToken != null && token.PrevToken.ForangeText == "c")
                {
                    result = "ион";
                }
                else
                {
                    result = "ён";
                }
            }

            return(result);
        }
        private static string TranslateL(LetterToken token)
        {
            //l	   –   л (перед твёрдым согласным), ль (перед мягких согласным)

            if (token.NextToken != null && IsSoftConsonant(token.NextToken))
            {
                return("ль");
            }
            return("л");
        }
示例#5
0
        private static string TranslateА(LetterToken token)
        {
            //{ "a", "а"}, //я после ģ ķ ļ ņ

            if (token.PrevToken != null && softConsonants.Contains(token.PrevToken.ForangeText.First()))
            {
                return("я");
            }
            return("а");
        }
示例#6
0
 private static string TranslateI(LetterToken token)
 {
     //{ "i", "и"},// ы в сочетаниях li, ni в конце слова
     //{ "ī", "и"},// ы в сочетаниях li, ni в конце слова
     if (token.PrevToken != null && (token.PrevToken.ForangeText == "l" || token.PrevToken.ForangeText == "n") &&
         token.NextToken == null)
     {
         return("ы");
     }
     return("и");
 }
        private static string TranslateE(LetterToken token)
        {
            //e	           –        э (в начале слова и после гласного, за исключением i в дифтонге ie), е (после согласных)
            //ę	           –        э (в начале слова и после гласного, за исключением i в дифтонге ie), е (после согласных)

            if (token.PrevToken != null && consonants.Contains(token.PrevToken.ForangeText.Last()))
            {
                return("е");
            }
            return("э");
        }
        private string TranslateI(LetterToken token)
        {
            // {"i", "и"}, //в дифтонгах после гласных    й
            var result = "и";

            if (token.PrevToken != null && vowels.Contains(token.PrevToken.ForangeText.Last()))
            {
                result = "й";
            }
            return(result);
        }
示例#9
0
        private static bool IsSoftConsonant(LetterToken token)
        {
            //согласными с последующим i, а также ć, l, ń, ś, ź
            var result = token.ForangeText.First() == 'ć' ||
                         token.ForangeText.First() == 'l' ||
                         token.ForangeText.First() == 'ń' ||
                         token.ForangeText.First() == 'ź' ||
                         token.ForangeText.First() == 'ś' || token.NextToken != null &&
                         token.NextToken.ForangeText.First() == 'i';

            return(result);
        }
示例#10
0
        private string TranslateDz(LetterToken token)
        {
            //{"dź", "дзь"},//перед мягкими согласными (то есть согласными с последующим i, а также ć, l, ń, ś, ź) дз
            var result = "дзь";

            if (token.NextToken != null && IsSoftConsonant(token.NextToken))
            {
                result = "дз";
            }

            return(result);
        }
示例#11
0
        private string TranslateZ(LetterToken token)
        {
            //{ "ź", "зь"},//перед согласными с последующим i, а также перед ć, l, ń, ś, dź	 з
            var result = "зь";

            if (token.NextToken != null && IsSoftConsonant(token.NextToken) && token.NextToken.ForangeText != "dź")
            {
                result = "з";
            }

            return(result);
        }
        private string TranslateE(LetterToken token)
        {
            // {"e", "э"},//после согласной и i	 е
            var result = "э";

            if (token.PrevToken != null && (consonants.Contains(token.PrevToken.ForangeText.Last()) ||
                                            token.PrevToken.ForangeText.Last() == 'i'))
            {
                result = "е";
            }
            return(result);
        }
示例#13
0
        private string TranslateS(LetterToken token)
        {
            //{"ś", "сь"},//перед согласными (кроме c) с последующим i, а также перед ć, l, ń, ś, ź	   - с
            var result = "сь";

            if (token.NextToken != null && IsSoftConsonant(token.NextToken) && token.NextToken.ForangeText != "c")
            {
                result = "с";
            }

            return(result);
        }
示例#14
0
        private string TranslateLa(LetterToken token)
        {
            //{ "lą", "лён"},//перед b, p	 лём, в остальных случаях	 лён
            var result = "лён";

            if (token.NextToken != null && (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
            {
                result = "лём";
            }

            return(result);
        }
        private string TranslateS(LetterToken token)
        {
            //{"s", "с"},//между гласными	 з
            var result = "с";

            if (token.PrevToken != null && token.NextToken != null &&
                vowels.Contains(token.PrevToken.ForangeText.Last()) &&
                vowels.Contains(token.NextToken.ForangeText.First()))
            {
                result = "з";
            }
            return(result);
        }
        private string TranslateC(LetterToken token)
        {
            //{"c","к"}, //перед e, i, y - с
            var result = "к";

            if (token.NextToken != null && (token.NextToken.ForangeText.First() == 'e' ||
                                            token.NextToken.ForangeText.First() == 'i' ||
                                            token.NextToken.ForangeText.First() == 'y'))
            {
                result = "с";
            }
            return(result);
        }
示例#17
0
        private string TranslateL(LetterToken token)
        {
            //{ "l", "л"},//ль в конце слова и перед соласной
            var result = "л";

            if (token.NextToken == null || token.NextToken != null &&
                consonants.Contains(token.NextToken.ForangeText.First()))
            {
                result = "ль";
            }

            return(result);
        }
示例#18
0
        private string TranslateJa(LetterToken token)
        {
            //{ "ją", "ён"},//в начале слова перед b, p   йом, в начале слова в остальных случаях	 йон,
            //после гласной перед b, p	 ём, после гласной в остальных случаях	 ён,
            //после согласной перед b, p	 ьом, после согласной в остальных случаях	 ьон
            var result = "ён";

            if (token.PrevToken == null || token.PrevToken != null &&
                vowels.Contains(token.PrevToken.ForangeText.Last()))
            {
                if (token.NextToken != null &&
                    (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
                {
                    result = "йом";
                }
                else
                {
                    result = "йон";
                }
            }

            if (token.PrevToken != null && vowels.Contains(token.PrevToken.ForangeText.Last()))
            {
                if (token.NextToken != null &&
                    (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
                {
                    result = "ём";
                }
                else
                {
                    result = "ён";
                }
            }

            if (token.PrevToken != null && consonants.Contains(token.PrevToken.ForangeText.Last()))
            {
                if (token.NextToken != null &&
                    (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
                {
                    result = "ьом";
                }
                else
                {
                    result = "ьон";
                }
            }

            return(result);
        }
示例#19
0
        private string TranslateA(LetterToken token)
        {
            // {"ą", "он"},//перед b, p ом, в конце слова	оу
            var result = "он";

            if (token.NextToken != null && (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
            {
                result = "ом";
            }

            if (token.NextToken == null)
            {
                result = "оу";
            }
            return(result);
        }
示例#20
0
        private string TranslateE(LetterToken token)
        {
            // {"ę", "ен"},//перед b, p	 ем, в конце слова и перед ł	е
            var result = "ен";

            if (token.NextToken != null && (token.NextToken.ForangeText == "b" || token.NextToken.ForangeText == "p"))
            {
                result = "ем";
            }

            if (token.NextToken == null || token.NextToken != null && token.NextToken.ForangeText == "ł")
            {
                result = "е";
            }
            return(result);
        }
示例#21
0
        private string TranslateY(LetterToken token)
        {
            //{"y", "ы"},//после cz, rz, sz, ż	 и,
            var result = "ы";

            if (token.PrevToken != null && (
                    token.PrevToken.ForangeText == "cz" ||
                    token.PrevToken.ForangeText == "rz" ||
                    token.PrevToken.ForangeText == "sz" ||
                    token.PrevToken.ForangeText == "ż"))
            {
                result = "и";
            }

            return(result);
        }
        private string TranslateAa(LetterToken token)
        {
            //{"ää", "яэ"},//в начале слова или компонента сложного слова	 ээ   в конце слова	 я
            var result = "яэ";

            if (token.StartPosition == 0 || token.PrevToken != null && token.PrevToken.ForangeText.Last() == '-')
            {
                result = "ээ";
            }

            if (token.NextToken == null)
            {
                result = "я";
            }
            return(result);
        }
示例#23
0
        private string TranslateCi(LetterToken token)
        {
            //{ "сі", "ци"},//перед e в конце слова, а также перед ó, u	   ч
            var result = "ци";

            if (token.NextToken != null && token.NextToken.ForangeText == "e" && token.NextToken.NextToken == null)
            {
                result = "ч";
            }

            if (token.NextToken != null && (token.NextToken.ForangeText == "ó" || token.NextToken.ForangeText == "u"))
            {
                result = "ч";
            }

            return(result);
        }
        private string TranslateEe(LetterToken token)
        {
            //{"ee", "ee"},  //ee    в начале слова  ээ,  после согласной	 еэ
            var result = "ee";

            if (token.StartPosition == 0)
            {
                result = "ээ";
            }

            if (token.PrevToken != null && consonants.Contains(token.PrevToken.ForangeText.Last()))
            {
                result = "еэ";
            }

            return(result);
        }
示例#25
0
        private static string TranslateJa(LetterToken token)
        {
            //{ "ja", "я"}, // в начале слова и после гласных
            //{ "ja", "ъя"}, // после g k l n
            //{ "ja", "ья"}, // после остальных согласных
            if (token.StartPosition == 0 ||
                token.PrevToken != null && vowels.Contains(token.PrevToken.ForangeText.Last()))
            {
                return("я");
            }

            if (token.PrevToken != null && hardConsonants.Contains(token.PrevToken.ForangeText.Last()))
            {
                return("ъя");
            }

            return("ья");
        }
        private static bool IsSoftConsonant(LetterToken token)
        {
            var result = token.RuText.First() == 'ч' || token.RuText.First() == 'щ' || token.RuText.First() == 'й';

            //ч, щ, й

            // И, Е, Ё, Ю, Я
            if (token.NextToken != null)
            {
                if (token.NextToken.RuText.First() == 'и' ||
                    token.NextToken.RuText.First() == 'е' ||
                    token.NextToken.RuText.First() == 'ё' ||
                    token.NextToken.RuText.First() == 'ю' ||
                    token.NextToken.RuText.First() == 'я')
                {
                    result = true;
                }
            }

            return(result);
        }
示例#27
0
        private string TranslateJo(LetterToken token)
        {
            //{ "jo", "ё"},//в начале слова	 йо, после гласной	 ё, после согласной	 ьо
            var result = "ё";

            if (token.PrevToken == null)
            {
                result = "йо";
            }
            if (token.PrevToken != null && vowels.Contains(token.PrevToken.ForangeText.Last()))
            {
                result = "ё";
            }

            if (token.PrevToken != null && consonants.Contains(token.PrevToken.ForangeText.Last()))
            {
                result = "ьо";
            }

            return(result);
        }
示例#28
0
        private static List <LetterToken> TokenizeString(string text)
        {
            var tokens = new List <LetterToken>();

            var ignoreCaseText = text.ToLowerInvariant();
            var textLength     = ignoreCaseText.Length;

            for (var index = 0; index < textLength; index++)
            {
                var fourLetters = string.Empty;
                var twoLetters  = string.Empty;

                if (index + 4 <= ignoreCaseText.Length)
                {
                    fourLetters = ignoreCaseText.Substring(index, 4);
                }

                if (index + 2 <= ignoreCaseText.Length)
                {
                    twoLetters = ignoreCaseText.Substring(index, 2);
                }

                var oneLetter = ignoreCaseText.Substring(index, 1);

                if (fourLettersReplaceRules.ContainsKey(fourLetters))
                {
                    var token = new LetterToken
                    {
                        StartPosition = index,
                        EndPosition   = index + 4,
                        ForangeText   = fourLetters,
                        RuText        = fourLettersReplaceRules[fourLetters]
                    };
                    tokens.Add(token);
                    index += 3;
                }
                else if (twoLettersReplaceRules.ContainsKey(twoLetters))
                {
                    var token = new LetterToken
                    {
                        StartPosition = index,
                        EndPosition   = index + 2,
                        ForangeText   = twoLetters,
                        RuText        = twoLettersReplaceRules[twoLetters]
                    };
                    tokens.Add(token);
                    index += 1;
                }
                else if (letterReplaceRules.ContainsKey(oneLetter))
                {
                    var token = new LetterToken
                    {
                        StartPosition = index,
                        EndPosition   = index,
                        ForangeText   = oneLetter,
                        RuText        = letterReplaceRules[oneLetter]
                    };
                    tokens.Add(token);
                }
                else
                {
                    var token = new LetterToken
                    {
                        StartPosition = index,
                        EndPosition   = index,
                        ForangeText   = oneLetter,
                        RuText        = oneLetter
                    };
                    tokens.Add(token);
                }
            }

            var result = tokens.OrderBy(t => t.StartPosition).ToList();

            for (var index = 0; index < tokens.Count; index++)
            {
                if (index != 0)
                {
                    result[index].PrevToken = result[index - 1];
                }
                if (index != tokens.Count - 1)
                {
                    result[index].NextToken = result[index + 1];
                }
            }
            return(result);
        }
示例#29
0
 private static string TranslateE(LetterToken token)
 {
     // { "e", "е"},//э (в начале слова), е (в остальных позициях)
     //{ "ē", "е"},//э (в начале слова), е (в остальных позициях)
     return(token.StartPosition == 0 ? "э" : "e");
 }