Пример #1
0
        public void testCheckEndsWithIndefiniteArticle2()
        {
            var cannedText = "I see a";

            var np = "cow";

            var expected = "I see a";

            var actual = DeterminerAgrHelper.checkEndsWithIndefiniteArticle(cannedText, np);

            Assert.AreEqual(expected, actual);
        }
        public virtual void testCheckEndsWithIndefiniteArticle2()
        {
            string cannedText = "I see a";

            string np = "cow";

            string expected = "I see a";

            string actual = DeterminerAgrHelper.checkEndsWithIndefiniteArticle(cannedText, np);

            Assert.AreEqual(expected, actual);
        }
Пример #3
0
        public override List <INLGElement> realise(List <INLGElement> elements)
        {
            var         realisedElements = new List <INLGElement>();
            INLGElement currentElement   = null;
            INLGElement determiner       = null;
            INLGElement prevElement      = null;

            if (elements != null)
            {
                foreach (var eachElement in elements)
                {
                    currentElement = realise(eachElement);

                    if (currentElement != null)
                    {
                        //pass the discourse function and appositive features -- important for orth processor
                        currentElement.setFeature(Feature.APPOSITIVE.ToString(),
                                                  eachElement.getFeature(Feature.APPOSITIVE.ToString()));
                        var function = eachElement.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString());

                        if (function != null)
                        {
                            currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(), function);
                        }

                        if (prevElement != null && prevElement is StringElement &&
                            eachElement is InflectedWordElement &&
                            (eachElement.getCategory().enumType == (int)LexicalCategoryEnum.NOUN))
                        {
                            var prevString = prevElement.getRealisation();

                            //realisedElements.get(realisedElements.size() - 1)

                            prevElement.setRealisation(DeterminerAgrHelper.checkEndsWithIndefiniteArticle(prevString,
                                                                                                          currentElement.getRealisation()));
                        }

                        // realisedElements.add(realise(currentElement));
                        realisedElements.add(currentElement);

                        if (determiner == null && DiscourseFunction.SPECIFIER.Equals(currentElement.getFeature(
                                                                                         InternalFeature.DISCOURSE_FUNCTION.ToString())))
                        {
                            determiner = currentElement;
                            determiner.setFeature(Feature.NUMBER.ToString(),
                                                  eachElement.getFeature(Feature.NUMBER.ToString()));
                            // MorphologyRules.doDeterminerMorphology(determiner,
                            // currentElement.getRealisation());
                        }
                        else if (determiner != null)
                        {
                            if (currentElement is ListElement)
                            {
                                // list elements: ensure det matches first element
                                INLGElement firstChild = ((ListElement)currentElement).getChildren().get(0);

                                if (firstChild != null)
                                {
                                    //AG: need to check if child is a coordinate
                                    if (firstChild is CoordinatedPhraseElement)
                                    {
                                        MorphologyRules.doDeterminerMorphology(determiner,
                                                                               firstChild.getChildren().get(0).getRealisation());
                                    }
                                    else
                                    {
                                        MorphologyRules.doDeterminerMorphology(determiner, firstChild.getRealisation());
                                    }
                                }
                            }
                            else
                            {
                                // everything else: ensure det matches realisation
                                MorphologyRules.doDeterminerMorphology(determiner, currentElement.getRealisation());
                            }

                            determiner = null;
                        }
                    }
                    prevElement = eachElement;
                }
            }

            return(realisedElements);
        }