Ejemplo n.º 1
0
        private static void VerbReflexivePronounLoad(this Lexemes santimenOfLexemes, XElement santimenOfLexemesNode)
        {
            var verbReflexivePronounRulesNodes = santimenOfLexemesNode.GetMultiNodes("VerbReflexivePronoun/Rule")
                                                 .RevealConfigNodes();

            foreach (var verbReflexivePronounRulesNode in verbReflexivePronounRulesNodes)
            {
                santimenOfLexemes.VerbReflexivePronoun.AppendRule
                (
                    verbReflexivePronounRulesNode.AttributeValue2Enum <Verbs>("Verb"),
                    verbReflexivePronounRulesNode.AttributeValue2Enum <Verbs>("SNT")
                );
            }
        }
Ejemplo n.º 2
0
        private static void AdverbAdverbLoad(this Lexemes santimenOfLexemes, XElement santimenOfLexemesNode)
        {
            var adverbAdverbRulesNodes = santimenOfLexemesNode.GetMultiNodes("AdverbAdverb/Rule")
                                         .RevealConfigNodes();

            foreach (var adverbAdverbRuleNode in adverbAdverbRulesNodes)
            {
                santimenOfLexemes.AdverbAdverb.AppendRule
                (
                    adverbAdverbRuleNode.AttributeValue2Enum <Adverbs>("Adverb1"),
                    adverbAdverbRuleNode.AttributeValue2Enum <Adverbs>("Adverb2"),
                    adverbAdverbRuleNode.AttributeValue2Enum <Adverbs>("SNT")
                );
            }
        }
Ejemplo n.º 3
0
        private static void AdjectiveNounLoad(this Lexemes santimenOfLexemes, XElement santimenOfLexemesNode)
        {
            var adjectiveNounRulesNodes = santimenOfLexemesNode.GetMultiNodes("AdjectiveNoun/Rule")
                                          .RevealConfigNodes();

            foreach (var adjectiveNounRuleNode in adjectiveNounRulesNodes)
            {
                santimenOfLexemes.AdjectiveNoun.AppendRule
                (
                    adjectiveNounRuleNode.AttributeValue2Enum <Adjectives>("Adjective"),
                    adjectiveNounRuleNode.AttributeValue2Enum <Nouns>("Noun"),
                    adjectiveNounRuleNode.AttributeValue2Enum <Nouns>("SNT")
                );
            }
        }
Ejemplo n.º 4
0
        public Rules(XElement rootRulesNode,
                     XElement rootRulesOrderNode,
                     XElement rootRulesOrderParticipialNode,
                     XElement rootRulesOrderHomogenousNode
                     )
        {
            Lexemes = new Lexemes();

            var subsentsNode = rootRulesNode.GetSingleNode("Subsentences");

            Subsentences = new Subsentences(subsentsNode);

            var sentencesNode = rootRulesNode.GetSingleNode("Sentences");

            Sentences = new Sentences(sentencesNode);

            var subordinateSubsentNode = rootRulesNode.GetSingleNode("SubordinateSubsent");

            SubordinateSubsent = new SubordinateSubsent(subordinateSubsentNode);

            var inquiryNode = rootRulesNode.GetSingleNode("Inquiry");

            Inquiry = new Inquiry(inquiryNode);

            UnionOfConcessionAndReversIntoductory = new UnionOfConcessionAndReversIntoductory(rootRulesNode);

            #region [.Rules by order.]
            var rulesIdsByOrder = rootRulesOrderNode.GetAttributeNodes("Rule/@id")
                                  .Select(_ => _.Value)
                                  .ToArray();

            _SubsentencesRulesByOrder = (from ruleId in rulesIdsByOrder
                                         select Subsentences.AllRules
                                         .ToArray()
                                         .FirstOrDefault(rule => rule.Id == ruleId)
                                         )
                                        .ToArray();

            if (_SubsentencesRulesByOrder.Any(rule => rule.IsNull()))
            {
                var notexists_rulesId = (from ruleId in rulesIdsByOrder
                                         let r = Subsentences.AllRules
                                                 .FirstOrDefault(rule => rule.Id == ruleId)
                                                 where (r == null)
                                                 select ruleId
                                         )
                                        .ToArray();
                throw (new ArgumentException("In rules-order file exists rules with names, which not exists in main-rules file: " + string.Join(", ", notexists_rulesId).InSingleQuote()));
            }
            #endregion

            #region [.Rules by order 4 participial (Subsents, only 4 types => Participle, DanglingParticiple, Subordinate & some-Default).]
            var rulesIdsByOrderParticipial = rootRulesOrderParticipialNode.GetAttributeNodes("Rule/@id")
                                             .Select(_ => _.Value)
                                             .ToArray();

            _SubsentencesRulesByOrder4Participial = (from ruleId in rulesIdsByOrderParticipial
                                                     select Subsentences.AllRules
                                                     .ToArray()
                                                     .FirstOrDefault(rule => rule.Id == ruleId)
                                                     )
                                                    .ToArray();

            if (_SubsentencesRulesByOrder4Participial.Any(rule => rule.IsNull()))
            {
                throw (new ArgumentException("In rules-order-participial file exists rules with names, which not exists in main-rules file."));
            }
            #endregion

            #region [.Rules by order 4 homogenous-entity.]
            var rulesIdsByOrderHomogenous = rootRulesOrderHomogenousNode.GetAttributeNodes("Rule/@id")
                                            .Select(_ => _.Value)
                                            .ToArray();

            _SubsentencesRulesByOrder4Homogenous = (from ruleId in rulesIdsByOrderHomogenous
                                                    select Subsentences.AllRules
                                                    .ToArray()
                                                    .FirstOrDefault(rule => rule.Id == ruleId)
                                                    )
                                                   .ToArray();

            if (_SubsentencesRulesByOrder4Homogenous.Any(rule => rule.IsNull()))
            {
                throw (new ArgumentException("In rules-order-homogenous file exists rules with names, which not exists in main-rules file."));
            }
            #endregion
        }