    001    // This file is part of the Attempto Java Packages.
    002    // Copyright 2008, Attempto Group, University of Zurich (see http://attempto.ifi.uzh.ch).
    003    //
    004    // The Attempto Java Packages is free software: you can redistribute it and/or modify it under the
    005    // terms of the GNU Lesser General Public License as published by the Free Software Foundation,
    006    // either version 3 of the License, or (at your option) any later version.
    007    //
    008    // The Attempto Java Packages is distributed in the hope that it will be useful, but WITHOUT ANY
    009    // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
    010    // PURPOSE. See the GNU Lesser General Public License for more details.
    011    //
    012    // You should have received a copy of the GNU Lesser General Public License along with the Attempto
    013    // Java Packages. If not, see http://www.gnu.org/licenses/.
    014
    015    package ch.uzh.ifi.attempto.ape;
    016
    017    /**
    018     * This class represents a single lexicon entry.
    019     *
    020     * @author Tobias Kuhn
    021     * @author Kaarel Kaljurand
    022     */
    023    public class LexiconEntry {
    024
    025            private String lexiconTerm;
    026
    027            /**
    028             * Creates a new lexicon entry on the basis of a string that is a serialization of a Prolog term.
    029             *
    030             * @param lexiconEntryString A string that is a serialized Prolog term representing a lexicon entry.
    031             */
    032            private LexiconEntry(String lexiconTerm) {
    033                    this.lexiconTerm = lexiconTerm;
    034            }
    035
    036            /**
    037             * Creates a new lexicon entry that defines the positive form of an adverb, for example "manually" or "fast".
    038             *
    039             * @param wordForm The word form how it should appear in the ACE texts.
    040             * @param symbol The symbol how it should appear in the logical representations.
    041             * @return The new lexicon entry.
    042             */
    043            public static LexiconEntry createAdvEntry(String wordForm, String symbol) {
    044                    return new LexiconEntry("adv(" + escape(wordForm) + ", " + escape(symbol) + ")");
    045            }
    046
    047            /**
    048             * Creates a new lexicon entry that defines the comparative form of an adverb, for example "faster".
    049             *
    050             * @param wordForm The word form how it should appear in the ACE texts.
    051             * @param symbol The symbol how it should appear in the logical representations.
    052             * @return The new lexicon entry.
    053             */
    054            public static LexiconEntry createAdvCompEntry(String wordForm, String symbol) {
    055                    return new LexiconEntry("adv_comp(" + escape(wordForm) + ", " + escape(symbol) + ")");
    056            }
    057
    058            /**
    059             * Creates a new lexicon entry that defines the superlative form of an adverb, for example "fastest".
    060             *
    061             * @param wordForm The word form how it should appear in the ACE texts.
    062             * @param symbol The symbol how it should appear in the logical representations.
    063             * @return The new lexicon entry.
    064             */
    065            public static LexiconEntry createAdvSupEntry(String wordForm, String symbol) {
    066                    return new LexiconEntry("adv_sup(" + escape(wordForm) + ", " + escape(symbol) + ")");
    067            }
    068
    069            /**
    070             * Creates a new lexicon entry that defines the positive form of an adjective, for example "rich".
    071             *
    072             * @param wordForm The word form how it should appear in the ACE texts.
    073             * @param symbol The symbol how it should appear in the logical representations.
    074             * @return The new lexicon entry.
    075             */
    076            public static LexiconEntry createAdjEntry(String wordForm, String symbol) {
    077                    return new LexiconEntry("adj_itr(" + escape(wordForm) + ", " + escape(symbol) + ")");
    078            }
    079
    080            /**
    081             * Creates a new lexicon entry that defines the comparative form of an adjective, for example "richer".
    082             *
    083             * @param wordForm The word form how it should appear in the ACE texts.
    084             * @param symbol The symbol how it should appear in the logical representations.
    085             * @return The new lexicon entry.
    086             */
    087            public static LexiconEntry createAdjCompEntry(String wordForm, String symbol) {
    088                    return new LexiconEntry("adj_itr_comp(" + escape(wordForm) + ", " + escape(symbol) + ")");
    089            }
    090
    091            /**
    092             * Creates a new lexicon entry that defines the superlative form of an adjective, for example "richest".
    093             *
    094             * @param wordForm The word form how it should appear in the ACE texts.
    095             * @param symbol The symbol how it should appear in the logical representations.
    096             * @return The new lexicon entry.
    097             */
    098            public static LexiconEntry createAdjSupEntry(String wordForm, String symbol) {
    099                    return new LexiconEntry("adj_itr_sup(" + escape(wordForm) + ", " + escape(symbol) + ")");
    100            }
    101
    102            /**
    103             * Creates a new lexicon entry that defines the positive form of a transitive adjective, for example "fond-of".
    104             *
    105             * @param wordForm The word form how it should appear in the ACE texts.
    106             * @param symbol The symbol how it should appear in the logical representations.
    107             * @param preposition The preposition of the transitive adjective, for example "of" in the case of "fond-of".
    108             * @return The new lexicon entry.
    109             */
    110            public static LexiconEntry createTrAdjEntry(String wordForm, String symbol, String preposition) {
    111                    return new LexiconEntry("adj_tr(" + escape(wordForm) + ", " + escape(symbol) + ", " + escape(preposition) + ")");
    112            }
    113
    114            /**
    115             * Creates a new lexicon entry that defines the comparative form of a transitive adjective, for example "fonder-of".
    116             *
    117             * @param wordForm The word form how it should appear in the ACE texts.
    118             * @param symbol The symbol how it should appear in the logical representations.
    119             * @param preposition The preposition of the transitive adjective, for example "of" in the case of "fonder-of".
    120             * @return The new lexicon entry.
    121             */
    122            public static LexiconEntry createTrAdjCompEntry(String wordForm, String symbol, String preposition) {
    123                    return new LexiconEntry("adj_tr_comp(" + escape(wordForm) + ", " + escape(symbol) + ", " + escape(preposition) + ")");
    124            }
    125
    126            /**
    127             * Creates a new lexicon entry that defines the superlative form of a transitive adjective, for example "fondest-of".
    128             *
    129             * @param wordForm The word form how it should appear in the ACE texts.
    130             * @param symbol The symbol how it should appear in the logical representations.
    131             * @param preposition The preposition of the transitive adjective, for example "of" in the case of "fondest-of".
    132             * @return The new lexicon entry.
    133             */
    134            public static LexiconEntry createTrAdjSupEntry(String wordForm, String symbol, String preposition) {
    135                    return new LexiconEntry("adj_tr_sup(" + escape(wordForm) + ", " + escape(symbol) + ", " + escape(preposition) + ")");
    136            }
    137
    138            /**
    139             * Creates a new lexicon entry that defines the singular form of a countable noun, for example "country".
    140             *
    141             * @param wordForm The word form how it should appear in the ACE texts.
    142             * @param symbol The symbol how it should appear in the logical representations.
    143             * @param gender The gender of the noun.
    144             * @return The new lexicon entry.
    145             */
    146            public static LexiconEntry createNounSgEntry(String wordForm, String symbol, Gender gender) {
    147                    return new LexiconEntry("noun_sg(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    148            }
    149
    150            /**
    151             * Creates a new lexicon entry that defines the plural form of a countable noun, for example "countries".
    152             *
    153             * @param wordForm The word form how it should appear in the ACE texts.
    154             * @param symbol The symbol how it should appear in the logical representations.
    155             * @param gender The gender of the noun.
    156             * @return The new lexicon entry.
    157             */
    158            public static LexiconEntry createNounPlEntry(String wordForm, String symbol, Gender gender) {
    159                    return new LexiconEntry("noun_pl(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    160            }
    161
    162            /**
    163             * Creates a new lexicon entry that defines a mass noun, for example "money".
    164             *
    165             * @param wordForm The word form how it should appear in the ACE texts.
    166             * @param symbol The symbol how it should appear in the logical representations.
    167             * @param gender The gender of the noun.
    168             * @return The new lexicon entry.
    169             */
    170            public static LexiconEntry createNounMassEntry(String wordForm, String symbol, Gender gender) {
    171                    return new LexiconEntry("noun_mass(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    172            }
    173
    174            /**
    175             * Creates a new lexicon entry that defines the singular form of a measurement noun, for example "mile", "km".
    176             *
    177             * @param wordForm The word form how it should appear in the ACE texts.
    178             * @param symbol The symbol how it should appear in the logical representations.
    179             * @return The new lexicon entry.
    180             */
    181            public static LexiconEntry createMeasureNounSgEntry(String wordForm, String symbol) {
    182                    return new LexiconEntry("mn_sg(" + escape(wordForm) + ", " + escape(symbol) + ")");
    183            }
    184
    185            /**
    186             * Creates a new lexicon entry that defines the plural form of a measurement noun, for example "miles", "km".
    187             *
    188             * @param wordForm The word form how it should appear in the ACE texts.
    189             * @param symbol The symbol how it should appear in the logical representations.
    190             * @return The new lexicon entry.
    191             */
    192            public static LexiconEntry createMeasureNounPlEntry(String wordForm, String symbol) {
    193                    return new LexiconEntry("mn_pl(" + escape(wordForm) + ", " + escape(symbol) + ")");
    194            }
    195
    196            /**
    197             * Creates a new lexicon entry that defines a singular proper name, for example "Switzerland".
    198             *
    199             * @param wordForm The word form how it should appear in the ACE texts.
    200             * @param symbol The symbol how it should appear in the logical representations.
    201             * @param gender The gender of the proper name.
    202             * @return The new lexicon entry.
    203             */
    204            public static LexiconEntry createPropernameSgEntry(String wordForm, String symbol, Gender gender) {
    205                    return new LexiconEntry("pn_sg(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    206            }
    207
    208            /**
    209             * Creates a new lexicon entry that defines a plural proper name, for example "United-States".
    210             *
    211             * @param wordForm The word form how it should appear in the ACE texts.
    212             * @param symbol The symbol how it should appear in the logical representations.
    213             * @param gender The gender of the proper name.
    214             * @return The new lexicon entry.
    215             */
    216            public static LexiconEntry createPropernamePlEntry(String wordForm, String symbol, Gender gender) {
    217                    return new LexiconEntry("pn_pl(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    218            }
    219
    220            /**
    221             * Creates a new lexicon entry that defines a singular proper name to be used with the definite article
    222             * "the", for example "the Nile".
    223             *
    224             * @param wordForm The word form how it should appear in the ACE texts.
    225             * @param symbol The symbol how it should appear in the logical representations.
    226             * @param gender The gender of the proper name.
    227             * @return The new lexicon entry.
    228             */
    229            public static LexiconEntry createPropernameDefSgEntry(String wordForm, String symbol, Gender gender) {
    230                    return new LexiconEntry("pndef_sg(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    231            }
    232
    233            /**
    234             * Creates a new lexicon entry that defines a plural proper name to be used with the definite article
    235             * "the", for example "the United-Nations".
    236             *
    237             * @param wordForm The word form how it should appear in the ACE texts.
    238             * @param symbol The symbol how it should appear in the logical representations.
    239             * @param gender The gender of the proper name.
    240             * @return The new lexicon entry.
    241             */
    242            public static LexiconEntry createPropernameDefPlEntry(String wordForm, String symbol, Gender gender) {
    243                    return new LexiconEntry("pndef_pl(" + escape(wordForm) + ", " + escape(symbol) + ", " + gender + ")");
    244            }
    245
    246            /**
    247             * Creates a new lexicon entry that defines the third singular form of an intransitive verb, for example "waits".
    248             *
    249             * @param wordForm The word form how it should appear in the ACE texts.
    250             * @param symbol The symbol how it should appear in the logical representations.
    251             * @return The new lexicon entry.
    252             */
    253            public static LexiconEntry createItrVerbThirdEntry(String wordForm, String symbol) {
    254                    return new LexiconEntry("iv_finsg(" + escape(wordForm) + ", " + escape(symbol) + ")");
    255            }
    256
    257            /**
    258             * Creates a new lexicon entry that defines the bare infinitive form of an intransitive verb, for example "wait".
    259             *
    260             * @param wordForm The word form how it should appear in the ACE texts.
    261             * @param symbol The symbol how it should appear in the logical representations.
    262             * @return The new lexicon entry.
    263             */
    264            public static LexiconEntry createItrVerbInfEntry(String wordForm, String symbol) {
    265                    return new LexiconEntry("iv_infpl(" + escape(wordForm) + ", " + escape(symbol) + ")");
    266            }
    267
    268            /**
    269             * Creates a new lexicon entry that defines the third singular form of a transitive verb, for example "contains".
    270             *
    271             * @param wordForm The word form how it should appear in the ACE texts.
    272             * @param symbol The symbol how it should appear in the logical representations.
    273             * @return The new lexicon entry.
    274             */
    275            public static LexiconEntry createTrVerbThirdEntry(String wordForm, String symbol) {
    276                    return new LexiconEntry("tv_finsg(" + escape(wordForm) + ", " + escape(symbol) + ")");
    277            }
    278
    279            /**
    280             * Creates a new lexicon entry that defines the bare infinitive form of a transitive verb, for example "contain".
    281             *
    282             * @param wordForm The word form how it should appear in the ACE texts.
    283             * @param symbol The symbol how it should appear in the logical representations.
    284             * @return The new lexicon entry.
    285             */
    286            public static LexiconEntry createTrVerbInfEntry(String wordForm, String symbol) {
    287                    return new LexiconEntry("tv_infpl(" + escape(wordForm) + ", " + escape(symbol) + ")");
    288            }
    289
    290            /**
    291             * Creates a new lexicon entry that defines the past participle form of a transitive verb, for example "contained".
    292             *
    293             * @param wordForm The word form how it should appear in the ACE texts.
    294             * @param symbol The symbol how it should appear in the logical representations.
    295             * @return The new lexicon entry.
    296             */
    297            public static LexiconEntry createTrVerbPPEntry(String wordForm, String symbol) {
    298                    return new LexiconEntry("tv_pp(" + escape(wordForm) + ", " + escape(symbol) + ")");
    299            }
    300
    301            /**
    302             * Creates a new lexicon entry that defines the third singular form of a ditransitive verb, for example "gives".
    303             *
    304             * @param wordForm The word form how it should appear in the ACE texts.
    305             * @param symbol The symbol how it should appear in the logical representations.
    306             * @param preposition The preposition for the indirect object.
    307             * @return The new lexicon entry.
    308             */
    309            public static LexiconEntry createDitrVerbThirdEntry(String wordForm, String symbol, String preposition) {
    310                    return new LexiconEntry("dv_finsg(" + escape(wordForm) + ", " + escape(symbol) + ", " + escape(preposition) + ")");
    311            }
    312
    313            /**
    314             * Creates a new lexicon entry that defines the bare infinitive form of a ditransitive verb, for example "give".
    315             *
    316             * @param wordForm The word form how it should appear in the ACE texts.
    317             * @param symbol The symbol how it should appear in the logical representations.
    318             * @param preposition The preposition for the indirect object.
    319             * @return The new lexicon entry.
    320             */
    321            public static LexiconEntry createDitrVerbInfEntry(String wordForm, String symbol, String preposition) {
    322                    return new LexiconEntry("dv_infpl(" + escape(wordForm) + ", " + escape(symbol) + ", " + escape(preposition) + ")");
    323            }
    324
    325            /**
    326             * Creates a new lexicon entry that defines the past participle form of a ditransitive verb, for example "given".
    327             *
    328             * @param wordForm The word form how it should appear in the ACE texts.
    329             * @param symbol The symbol how it should appear in the logical representations.
    330             * @param preposition The preposition for the indirect object.
    331             * @return The new lexicon entry.
    332             */
    333            public static LexiconEntry createDitrVerbPPEntry(String wordForm, String symbol, String preposition) {
    334                    return new LexiconEntry("dv_pp(" + escape(wordForm) + ", " + escape(symbol) + ", " + escape(preposition) + ")");
    335            }
    336
    337            /**
    338             * Creates a new lexicon entry that defines a preposition, for example "for".
    339             *
    340             * @param wordForm The word form how it should appear in the ACE texts.
    341             * @param symbol The symbol how it should appear in the logical representations.
    342             * @return The new lexicon entry.
    343             */
    344            public static LexiconEntry createPrepEntry(String wordForm, String symbol) {
    345                    return new LexiconEntry("prep(" + escape(wordForm) + ", " + escape(symbol) + ")");
    346            }
    347
    348            /**
    349             * Returns the plain text serialization for this lexicon entry.
    350             *
    351             * @return The plain text serialization for this lexicon entry.
    352             */
    353            @Override
    354            public String toString() {
    355                    return lexiconTerm;
    356            }
    357
    358            private static String escape(String str) {
    359                    return PrologUtils.escape(str);
    360            }
    361
    362            public boolean equals(Object obj) {
    363                    if (obj instanceof LexiconEntry) {
    364                            LexiconEntry other = (LexiconEntry) obj;
    365                            return this.toString().equals(other.toString());
    366                    } else {
    367                            return false;
    368                    }
    369            }
    370
    371    }