com.force.i18n.grammar

Class LanguageDeclension

java.lang.Object

com.force.i18n.grammar.LanguageDeclension

Direct Known Subclasses:

ArticledDeclension, TamilDeclension

public abstract class LanguageDeclension
extends Object

Represents the Declensions (or Noun Forms and their uses) associated with a language. This also contains information about the specifics of noun usage in a language, such as whether "starts with" is imports. Each language (in general) will get its own declension.These classes should be treated like enums.

Author:

stamm

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	LanguageDeclension.PluralNounForm Simple noun form with singular and plurals
static class	LanguageDeclension.SimpleAdjective Represents a simple adjective with a single form.
static class	LanguageDeclension.SimpleAdjectiveWithStartsWith Represents a simple adjective for use in languages that have "startsWith" for articles and modifiers.
static class	LanguageDeclension.SimpleModifierForm SIMPLE FORMS: Often times, complex declension have simple forms of one thing or another.
static class	LanguageDeclension.SimplePluralNoun Represents a simple noun with a singular and plural form.

Constructor Summary

Constructors

Constructor and Description
LanguageDeclension(HumanLanguage language)

Method Summary

Modifier and Type	Method and Description
protected abstract Adjective	createAdjective(String name, LanguageStartsWith startsWith, LanguagePosition position)
protected Article	createArticle(String name, LanguageArticle articleType)
Noun	createNoun(String name, Noun.NounType type, String entityName, LanguageStartsWith startsWith, LanguageGender gender, Map<? extends NounForm,String> forms) Accessor for creating custom nouns simply based on all of the forms.
Noun	createNoun(String name, Noun.NounType type, String entityName, ResultSet rs) Helper method for creating a noun from the database
protected abstract Noun	createNoun(String name, String pluralAlias, Noun.NounType type, String entityName, LanguageStartsWith startsWith, LanguageGender gender, String access, boolean isStandardField, boolean isCopied)
protected static <K extends Enum<K>,V> EnumMap<K,V>	enumMapFilterNulls(K k1, V v1, K k2, V v2) Create a new EnumMap with the given keys and values, only including an entry if the value and key are not null This is used instead of ImmutableMap, because that doesn't allow null values
protected static <K extends Enum<K>,V> EnumMap<K,V>	enumMapFilterNulls(K k1, V v1, K k2, V v2, K k3, V v3) Create a new EnumMap with the given keys and values, only including an entry if the value and key are not null This is used instead of ImmutableMap, because that doesn't allow null values
protected static <K extends Enum<K>,V> EnumMap<K,V>	enumMapFilterNulls(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) Create a new EnumMap with the given keys and values, only including an entry if the value and key are not null This is used instead of ImmutableMap, because that doesn't allow null values
String	formLowercaseNounForm(String s, NounForm form)
AdjectiveForm	getAdjectiveForm(AdjectiveForm af)
AdjectiveForm	getAdjectiveForm(LanguageStartsWith startsWith, LanguageGender gender, LanguageNumber number, LanguageCase _case, LanguageArticle article, LanguagePossessive possessive)
abstract List<? extends AdjectiveForm>	getAdjectiveForms()
abstract List<? extends NounForm>	getAllNounForms()
Set<LanguageArticle>	getAllowedArticleTypes()
EnumSet<LanguageCase>	getAllowedCases()
AdjectiveForm	getApproximateAdjectiveForm(LanguageStartsWith startsWith, LanguageGender gender, LanguageNumber number, LanguageCase _case, LanguageArticle article, LanguagePossessive possessive)
ArticleForm	getApproximateArticleForm(LanguageStartsWith startsWith, LanguageGender gender, LanguageNumber number, LanguageCase _case)
NounForm	getApproximateNounForm(LanguageNumber number, LanguageCase _case, LanguagePossessive possessive, LanguageArticle article)
ArticleForm	getArticleForm(ArticleForm af)
ArticleForm	getArticleForm(LanguageStartsWith startsWith, LanguageGender gender, LanguageNumber number, LanguageCase _case)
List<? extends ArticleForm>	getArticleForms() a
LanguagePosition	getDefaultAdjectivePosition()
LanguageArticle	getDefaultArticle()
LanguageCase	getDefaultCase()
LanguageGender	getDefaultGender()
LanguagePossessive	getDefaultPossessive()
LanguageStartsWith	getDefaultStartsWith()
abstract Collection<? extends NounForm>	getEntityForms() For entities, we need with-article forms, but validation method will fix those values automatically.
NounForm	getExactNounForm(LanguageNumber number, LanguageCase _case, LanguagePossessive possessive, LanguageArticle article)
abstract Collection<? extends NounForm>	getFieldForms()
HumanLanguage	getLanguage()
NounForm	getNounForm(LanguageNumber number, LanguageArticle articleType)
NounForm	getNounForm(LanguageNumber number, LanguageCase caseType)
NounForm	getNounForm(NounForm nf)
abstract Collection<? extends NounForm>	getOtherForms()
EnumSet<LanguageCase>	getRequiredCases()
EnumSet<LanguageGender>	getRequiredGenders()
EnumSet<LanguagePossessive>	getRequiredPossessive()
EnumSet<LanguageStartsWith>	getRequiredStartsWith()
boolean	hasAllowedCases()
boolean	hasArticle()
boolean	hasArticleInNounForm()
boolean	hasAutoDerivedStartsWith() Certain languages have strict rules for determining the starts with of an adjective, such as greek.
boolean	hasCapitalization()
abstract boolean	hasGender() Convenient method to tell that the language has gender. In English, it is false.
boolean	hasPlural() convenient method to tell that the language has plural form In English, it is true.
boolean	hasPossessive() convenient method to tell that the language has possessive form.
boolean	hasPossessiveInAdjective()
boolean	hasRequiredCases()
abstract boolean	hasStartsWith() convenient method to tell that the language has to know the noun, which starts with vowel (includes soft-sounds like Hour).
boolean	hasStartsWithInAdjective()
boolean	hasSubjectGenderInVerbConjugation() This method is used to determine whether to display a "warning" in rename tabs about there being gramatical issues around renaming gender
boolean	isArticleInNounFormAutoDerived()
boolean	isInflected()
boolean	moveNounInflectionToFirstModifier() Label file processing should change so that any modifier on a noun should move from the noun to the first modifier, if one exists.
boolean	shouldInferNounDefArticleFromParticle() For languages where the noun has a different form based on the article (Nordic), should the article="the" on the noun be inferred from the existence of the <The> particle? NOTE: THIS ONLY WORKS FOR THE DEFINITE ARTICLE
boolean	shouldLowercaseEntityInCompoundNouns()
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

LanguageDeclension

public LanguageDeclension(HumanLanguage language)

Method Detail

getLanguage

public final HumanLanguage getLanguage()

Returns:

the language of this declension

getAllNounForms

public abstract List<? extends NounForm> getAllNounForms()

Returns:

all the forms that are associated with nouns in a list

getEntityForms

public abstract Collection<? extends NounForm> getEntityForms()

For entities, we need with-article forms, but validation method will fix those values automatically. See Noun.fixValueWithArticle

getFieldForms

public abstract Collection<? extends NounForm> getFieldForms()

Returns:

the forms that can be associated with "fields"

getOtherForms

public abstract Collection<? extends NounForm> getOtherForms()

Returns:

the forms that can be associated with adjectives and other modifiers

getAdjectiveForms

public abstract List<? extends AdjectiveForm> getAdjectiveForms()

Returns:

all of the various forms of adjectives available in the dictionary

getArticleForms

public List<? extends ArticleForm> getArticleForms()

a

Returns:

all of the various forms of articles available in the dictionary

createNoun

protected abstract Noun createNoun(String name,
                                   String pluralAlias,
                                   Noun.NounType type,
                                   String entityName,
                                   LanguageStartsWith startsWith,
                                   LanguageGender gender,
                                   String access,
                                   boolean isStandardField,
                                   boolean isCopied)

Parameters:

entityName - TODO

Returns:

Return the noun implementation for this language

createNoun

public Noun createNoun(String name,
                       Noun.NounType type,
                       String entityName,
                       LanguageStartsWith startsWith,
                       LanguageGender gender,
                       Map<? extends NounForm,String> forms)

Accessor for creating custom nouns simply based on all of the forms. Should be used by the "renaming provider"

createNoun

public Noun createNoun(String name,
                       Noun.NounType type,
                       String entityName,
                       ResultSet rs)
                throws SQLException

Helper method for creating a noun from the database

Parameters:

name - the name of the noun

type - the noun type

entityName - the name of the standard entity this noun is associated with, or null if it's custom or irrelevant

rs - a cursor against the label_data or custom_entity_translation tables

Throws:

SQLException

createAdjective

protected abstract Adjective createAdjective(String name,
                                             LanguageStartsWith startsWith,
                                             LanguagePosition position)

Parameters:

name - TODO

startsWith - TODO

position - TODO

Returns:

a language specific implementation for modifiers/adjectives in this language

createArticle

protected Article createArticle(String name,
                                LanguageArticle articleType)

Parameters:

name - TODO

articleType - the type of article

Returns:

a language specific implementation for modifiers/adjectives in this language

hasGender

public abstract boolean hasGender()

Convenient method to tell that the language has gender.
In English, it is false. Subclass must override this method to return the correct value. Note that subclass may also need to override int[] getRequiredGenders.

Returns:

true if the language has concept of gender

hasStartsWith

public abstract boolean hasStartsWith()

convenient method to tell that the language has to know the noun, which starts with vowel (includes soft-sounds like Hour).
In English, it is true. Subclass must override this method to return the correct value. Note that subclass may also need to override Element createStartsWithElement(String, Noun, boolean) too.

Returns:

true if the language modifier(article/adjective) have different value if it starts with vowel.

hasStartsWithInAdjective

public boolean hasStartsWithInAdjective()

Returns:

true if adjectives are dependent on whether the noun starts with a vowel. If false, custom objects do not need to collect the startsWith information on their names, since we only use their names with simple adjectives and we do not compose sentences with them.

hasAutoDerivedStartsWith

public boolean hasAutoDerivedStartsWith()

Certain languages have strict rules for determining the starts with of an adjective, such as greek. If this is enabled, the display for "hasStartsWith" in the UI will be suppressed.

Returns:

whether startswith is autoderivable from a given form.

hasPlural

public boolean hasPlural()

convenient method to tell that the language has plural form In English, it is true. Subclass must override this method to return the correct value.

Returns:

true if the language has concept of number (singular/plural)

hasPossessive

public boolean hasPossessive()

convenient method to tell that the language has possessive form. In English, it is false. Subclass must override this method to return the correct value.

Returns:

true if the language has concept of possessive (first/second/third person possessive)

hasPossessiveInAdjective

public boolean hasPossessiveInAdjective()

Returns:

true if there are different adjective forms based on the possessive

hasArticle

public boolean hasArticle()

Returns:

true if the language has a different form based on article NOTE: If you override this, you pretty much have to extend from ArticledDeclension.

hasArticleInNounForm

public boolean hasArticleInNounForm()

Returns:

true if there are different noun forms based on the article (i.e. the article isn't a modifier, but is an irregular suffix)

isArticleInNounFormAutoDerived

public boolean isArticleInNounFormAutoDerived()

Returns:

whether the article form for a noun is autoderived

hasRequiredCases

public boolean hasRequiredCases()

Returns:

true if the language has different form based on cases

hasAllowedCases

public boolean hasAllowedCases()

Returns:

true if the language has different form based on cases

hasCapitalization

public boolean hasCapitalization()

Returns:

true if the language has a distinction between capital and lowercase letters. If false, most of the lowercasing is ignored globally.

getRequiredGenders

public EnumSet<LanguageGender> getRequiredGenders()

Returns:

set of NEUTER, FEMININE or MASCULINE, null if nothing apply

getRequiredCases

public EnumSet<LanguageCase> getRequiredCases()

Returns:

set of NOMINATIVE, ACCUSATIVE, GENITIVE or DATIVE

getAllowedCases

public EnumSet<LanguageCase> getAllowedCases()

Returns:

the set of allowed cases for a noun/adjective; which differs from the required cases in that the "allowed" cases may include auto-derived forms.

getRequiredStartsWith

public EnumSet<LanguageStartsWith> getRequiredStartsWith()

Returns:

set of which "starts with" values are "required"

getRequiredPossessive

public EnumSet<LanguagePossessive> getRequiredPossessive()

Returns:

array of values of POSSESSIVE_NONE, POSSESSIVE_FIRST, POSSESSIVE_SECOND or POSSESSIVE_THIRD

getDefaultGender

public LanguageGender getDefaultGender()

Returns:

default gender value for this language

getDefaultStartsWith

public LanguageStartsWith getDefaultStartsWith()

Returns:

default value for this language

getDefaultAdjectivePosition

public LanguagePosition getDefaultAdjectivePosition()

Returns:

the default position of adjectives that needs to be overridden in the language files

getDefaultCase

public LanguageCase getDefaultCase()

Returns:

default value for this language

getDefaultArticle

public LanguageArticle getDefaultArticle()

Returns:

default value for this language

getDefaultPossessive

public LanguagePossessive getDefaultPossessive()

Returns:

default value for this language

isInflected

public boolean isInflected()

Returns:

whether or not this language has an inflected declension (i.e. is not a simple declension) Generally isolating languages are non-inflected

moveNounInflectionToFirstModifier

public boolean moveNounInflectionToFirstModifier()

Label file processing should change so that any modifier on a noun should move from the noun to the first modifier, if one exists. For bulgarian.

Returns:

whether this language needs special processing of modifiers in noun phrases

hasSubjectGenderInVerbConjugation

public boolean hasSubjectGenderInVerbConjugation()

This method is used to determine whether to display a "warning" in rename tabs about there being gramatical issues around renaming gender

Returns:

whether verbs are inflected differently based on the gender of the subject

getExactNounForm

public NounForm getExactNounForm(LanguageNumber number,
                                 LanguageCase _case,
                                 LanguagePossessive possessive,
                                 LanguageArticle article)

Returns:

Return the appropriate noun form for this language based on the form parameters provided

getAllowedArticleTypes

public Set<LanguageArticle> getAllowedArticleTypes()

Returns:

The set of articles allowed in the language. By default is empty

shouldInferNounDefArticleFromParticle

public boolean shouldInferNounDefArticleFromParticle()

For languages where the noun has a different form based on the article (Nordic), should the article="the" on the noun be inferred from the existence of the <The> particle? NOTE: THIS ONLY WORKS FOR THE DEFINITE ARTICLE

getApproximateNounForm

public NounForm getApproximateNounForm(LanguageNumber number,
                                       LanguageCase _case,
                                       LanguagePossessive possessive,
                                       LanguageArticle article)

Returns:

Return the appropriate noun form for this language based on the form parameters provided. Simple languages should reimplement this to provide a quicker and more direct response

getNounForm

public final NounForm getNounForm(LanguageNumber number,
                                  LanguageCase caseType)

getNounForm

public final NounForm getNounForm(LanguageNumber number,
                                  LanguageArticle articleType)

getNounForm

public NounForm getNounForm(NounForm nf)

getAdjectiveForm

public AdjectiveForm getAdjectiveForm(AdjectiveForm af)

getAdjectiveForm

public AdjectiveForm getAdjectiveForm(LanguageStartsWith startsWith,
                                      LanguageGender gender,
                                      LanguageNumber number,
                                      LanguageCase _case,
                                      LanguageArticle article,
                                      LanguagePossessive possessive)

getApproximateAdjectiveForm

public AdjectiveForm getApproximateAdjectiveForm(LanguageStartsWith startsWith,
                                                 LanguageGender gender,
                                                 LanguageNumber number,
                                                 LanguageCase _case,
                                                 LanguageArticle article,
                                                 LanguagePossessive possessive)

Parameters:

possessive - TODO

Returns:

Return the appropriate noun form for this language based on the form parameters provided. Simple languages should reimplement this to provide a quicker and more direct response

getApproximateArticleForm

public ArticleForm getApproximateArticleForm(LanguageStartsWith startsWith,
                                             LanguageGender gender,
                                             LanguageNumber number,
                                             LanguageCase _case)

getArticleForm

public ArticleForm getArticleForm(ArticleForm af)

getArticleForm

public ArticleForm getArticleForm(LanguageStartsWith startsWith,
                                  LanguageGender gender,
                                  LanguageNumber number,
                                  LanguageCase _case)

shouldLowercaseEntityInCompoundNouns

public boolean shouldLowercaseEntityInCompoundNouns()

Returns:

true if compound nouns should, generally, be lowercased in compound nouns. This is used to determine defaults on the renaming screens.

formLowercaseNounForm

public String formLowercaseNounForm(String s,
                                    NounForm form)

Parameters:

s - the string to lowercase

form - the form of the noun to lowercase

Returns:

the lowercase form of a noun that should be used if a non-capitalized version of the noun was asked for in a Label Ref. This is used in german to deal with capitalization of "Ein Account" vs "ein Account", where the Account should generally always be capitalized.

toString

public String toString()

Overrides:

toString in class Object

enumMapFilterNulls

protected static <K extends Enum<K>,V> EnumMap<K,V> enumMapFilterNulls(K k1,
                                                                       V v1,
                                                                       K k2,
                                                                       V v2)

Create a new EnumMap with the given keys and values, only including an entry if the value and key are not null This is used instead of ImmutableMap, because that doesn't allow null values

enumMapFilterNulls

protected static <K extends Enum<K>,V> EnumMap<K,V> enumMapFilterNulls(K k1,
                                                                       V v1,
                                                                       K k2,
                                                                       V v2,
                                                                       K k3,
                                                                       V v3)

Create a new EnumMap with the given keys and values, only including an entry if the value and key are not null This is used instead of ImmutableMap, because that doesn't allow null values

enumMapFilterNulls

protected static <K extends Enum<K>,V> EnumMap<K,V> enumMapFilterNulls(K k1,
                                                                       V v1,
                                                                       K k2,
                                                                       V v2,
                                                                       K k3,
                                                                       V v3,
                                                                       K k4,
                                                                       V v4)

Create a new EnumMap with the given keys and values, only including an entry if the value and key are not null This is used instead of ImmutableMap, because that doesn't allow null values