Exemple #1
0
        public static bool IsClause(IAdTree adTree, IAttributesModel attributesModel)
        {
            var found  = adTree?.GetRightSequence().FirstOrDefault(x => attributesModel.IsVerb(x.Morpheme.Attributes) || attributesModel.IsU(x.Morpheme.Attributes));
            var result = found != null && attributesModel.IsVerb(found.Morpheme.Attributes);

            return(result);
        }
Exemple #2
0
        private static bool CanAttachViaRule(this IAdTree adTree, IAdTree adTreeToAttach, AttachingPosition attachPosition, IAttributesModel attributesModel)
        {
            // Get rule to evalute.
            MorphemeRule rule = attachPosition == AttachingPosition.ChildOnLeft ? adTree.Pattern.LeftRule : adTree.Pattern.RightRule;

            // If the rule allows to attach and the order of attaching is correct.
            if (!rule.Equals(MorphemeRule.Nothing) && IsAttachingOrderCorrect(adTree, attachPosition))
            {
                // If the adtree where to attach is morphematic then it is not possible to attach the second child until the morpheme is set.
                if (adTree.Pattern.IsMorphematicAdPosition() && (adTree.Right != null || adTree.Left != null) && string.IsNullOrEmpty(adTree.Morpheme.Morph))
                {
                    return(false);
                }

                // Note: from the tree to attach we need to get the adtree representing the morpheme which shall be evaluated.
                IAdTree morphemeAdTree = null;

                // If the adTreeToAttach is a morpheme or a transference.
                if (adTreeToAttach.Pattern.IsLikeMorpheme)
                {
                    morphemeAdTree = adTreeToAttach;
                }
                // It is an adposition.
                else if (adTreeToAttach.Pattern.IsEpsilonAdPosition() ||
                         adTreeToAttach.Pattern.IsMorphematicAdPosition())
                {
                    // If a substitution (because adTreeToAttach is adposition) can be attached.
                    if (rule.SubstitutionRule.Evaluate(adTreeToAttach.Morpheme.GrammarCharacter))
                    {
                        // If it shall be attached to the right and
                        // the valency position is specified then check correctness with regard to presence of previously filled valencies.
                        if (attachPosition == AttachingPosition.ChildOnRight)
                        {
                            IAdTree valencyElement = adTree.GetSequenceToRoot()
                                                     .TakeUntil(x => x.IsOnRight)
                                                     .FirstOrDefault(x => x.Pattern.ValencyPosition > 0);

                            if (valencyElement != null)
                            {
                                IAdTree previousValencyElement = adTreeToAttach.GetRightSequence()
                                                                 .FirstOrDefault(x => x.Pattern.ValencyPosition > 0);

                                if (previousValencyElement == null && valencyElement.Pattern.ValencyPosition > 1 ||
                                    previousValencyElement != null && valencyElement.Pattern.ValencyPosition != previousValencyElement.Pattern.ValencyPosition + 1)
                                {
                                    return(false);
                                }
                            }
                        }

                        // Try to get the driving morpheme.
                        morphemeAdTree = adTreeToAttach.RightChildren.FirstOrDefault(x => x.Pattern.IsLikeMorpheme);

                        // If the governor is not attached yet then check only rules.
                        if (morphemeAdTree == null)
                        {
                            IEnumerable <IAdTree> rightSequence = new IAdTree[] { adTreeToAttach }.Concat(adTreeToAttach.RightChildren);
                            if (rightSequence.Any(x => !x.Pattern.RightRule.IsSubruleOf(rule) && !rule.IsSubruleOf(x.Pattern.RightRule)))
                            {
                                return(false);
                            }

                            return(true);
                        }
                    }
                }

                if (morphemeAdTree != null)
                {
                    // If it shall be attached to the right the morpheme is a verb then check the valency.
                    if (attachPosition == AttachingPosition.ChildOnRight && attributesModel.IsVerb(morphemeAdTree.Morpheme.Attributes))
                    {
                        int valency = attributesModel.GetNumberOfValencies(morphemeAdTree.Morpheme.Attributes);

                        if (valency > -1)
                        {
                            // Get already filled valency positions.
                            int[] valencyPositions = morphemeAdTree.GetSequenceToRoot()
                                                     .TakeWhile(x => x != adTree) // This is to not make an assuption if it is already attached or not.
                                                     .TakeUntil(x => x.IsOnRight)
                                                     .Concat(adTree.GetSequenceToRoot().TakeUntil(x => x.IsOnRight))
                                                     .Where(x => x.Pattern.ValencyPosition > 0)
                                                     .Select(x => x.Pattern.ValencyPosition)
                                                     .ToArray();

                            // If such valency is already filled.
                            if (valencyPositions.Length > valency)
                            {
                                return(false);
                            }
                            for (int i = 0; i < valencyPositions.Length; ++i)
                            {
                                if (valencyPositions[i] != i + 1)
                                {
                                    return(false);
                                }
                            }
                        }
                    }

                    Morpheme morphemeToEvaluate = morphemeAdTree.TryGetTransferenceMorpheme();

                    if (string.IsNullOrEmpty(morphemeToEvaluate?.Morph) && morphemeAdTree.Pattern.IsPairTransference)
                    {
                        // The morpheme with the morph is not attached yet so check only attributes.
                        if (rule.AttributesRule.Evaluate(morphemeAdTree.Morpheme.Attributes))
                        {
                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }

                    // Check if the morpheme passes the rule.
                    bool result = rule.Evaluate(morphemeToEvaluate);
                    return(result);
                }
            }

            return(false);
        }