Utils (LanguageTool 6.4-SNAPSHOT API)

java.lang.Object
- org.languagetool.tagging.ga.Utils

```
public class Utils
extends Object
```

Constructor Summary

Constructors
Constructor and Description

Utils()

Constructors
Constructor and Description
`Utils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`containsPonc(String s)`
`static Retaggable`	`demutate(String in)`
`static String`	`eclipse(String in)` eclipses a word ("Eclipsis" in Irish grammar is an initial mutation, represented as a prefix to the word that replaces the pronunciation of the letter for consonants, i.e., 'f' is eclipsed as 'bh' - 'focal' becomes 'bhfocal' - but only 'bh' (not 'f') is pronounced; or, with vowels, an initial 'n' is added (hyphenated before a lowercase word, lowercased but not hyphenated before an uppercase or titlecase word).
`static Retaggable`	`fixSuffix(String in)`
`static String`	`greekToLatin(String s)`
`static String`	`halfwidthLatinToLatin(String s)`
`static boolean`	`hasMixedGreekAndCyrillic(String s)`
`static boolean`	`hasMixedGreekAndLatin(String s)`
`static boolean`	`isAllHalfWidthChars(String s)`
`static boolean`	`isAllMathsChars(String s)`
`static boolean`	`isAllUppercase(String s)`
`static boolean`	`isLowerLenitable(char c)`
`static boolean`	`isLowerVowel(char c)`
`static boolean`	`isPonc(char c)` Check if the character is dotted ('ponc' in Irish)
`static boolean`	`isSLenitable(char c)` The (non-definite) eclipsed form of 's', 'sh', is pronounced like 'h' in English; words beginning with 's' can only have lenition applied if the following letter would be easily pronounced after this sound: this function checks if the that second letter is one of them
`static boolean`	`isUpperLenitable(char c)`
`static boolean`	`isUpperVowel(char c)`
`static boolean`	`isVowel(char c)`
`static String`	`lenite(String in)` lenites a word ("Lenition" in Irish grammar is an initial mutation, historically related to phonetic lenition; its written representation is an 'h' after the initial consonant).
`static List<Retaggable>`	`morphWord(String in)`
`static String`	`simplifyMathematical(String s)`
`static String`	`simplifyMathematical(String s, boolean normaliseGreek, boolean normaliseDigits)`
`static boolean`	`startsWithUppercase(String s)` Equivalent of `StringTools.startsWithUppercase(String)`, adapted for Irish case folding oddities.
`static String`	`toLowerCaseIrish(String s)` Case folding in Irish is non-trivial: initial mutations that prefix the word are always written in lowercase; 'n' and 't' are written with a hyphen before a lowercase vowel.
`static String`	`unEclipse(String in)`
`static String`	`unEclipseChar(String in, char first, char second)` Helper to uneclipse single-letter consonant eclipsis (i.e., not bhfear or n-éin), handling miscapitalised eclipsed words: Gcarr -> Carr, etc.
`static String`	`unEclipseF(String in)`
`static String`	`unLenite(String in)` Attempts to unlenite a string (See `lenite(String)`) Deliberately does not check if first character is one that ought to be lenited (this can be checked in XML rules)
`static String`	`unLeniteDefiniteS(String in)` Removes lenition from a word beginning with 's', following the definite article; as an exception to conventional lenition, this is a 't' prefix.
`static String`	`unPonc(String s)` Converts pre-standard lenition to modern (converts dotted (= ponc) letters to the equivalent undotted, followed by 'h'

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Utils
```
public Utils()
```
- Method Detail
  - fixSuffix
```
public static Retaggable fixSuffix(String in)
```
  - morphWord
```
public static List<Retaggable> morphWord(String in)
```
  - demutate
```
public static Retaggable demutate(String in)
```
  - unEclipse
```
public static String unEclipse(String in)
```
  - unLenite
```
public static String unLenite(String in)
```
    Attempts to unlenite a string (See lenite(String)) Deliberately does not check if first character is one that ought to be lenited (this can be checked in XML rules)
  - unLeniteDefiniteS
```
public static String unLeniteDefiniteS(String in)
```
    Removes lenition from a word beginning with 's', following the definite article; as an exception to conventional lenition, this is a 't' prefix. The standard representation is a lowercase 't', regardless of the case of the word; this function additionally checks for incorrect (e.g., capital 'T') and prestandard (e.g., hyphenated 't-') versions.
    
    Parameters:
    
    in - The written form
    
    Returns:
    
    The form with lenition removed
  - unEclipseF
```
public static String unEclipseF(String in)
```
  - unEclipseChar
```
public static String unEclipseChar(String in,
                                   char first,
                                   char second)
```
    Helper to uneclipse single-letter consonant eclipsis (i.e., not bhfear or n-éin), handling miscapitalised eclipsed words: Gcarr -> Carr, etc.
    
    Parameters:
    
    in - string to uneclipse
    
    first - first (eclipsis) character
    
    second - second character; first character of the word proper
    
    Returns:
    
    String with uneclipsed word or null if no match
  - isUpperVowel
```
public static boolean isUpperVowel(char c)
```
  - isLowerVowel
```
public static boolean isLowerVowel(char c)
```
  - isVowel
```
public static boolean isVowel(char c)
```
  - isUpperLenitable
```
public static boolean isUpperLenitable(char c)
```
  - isLowerLenitable
```
public static boolean isLowerLenitable(char c)
```
  - isSLenitable
```
public static boolean isSLenitable(char c)
```
    The (non-definite) eclipsed form of 's', 'sh', is pronounced like 'h' in English; words beginning with 's' can only have lenition applied if the following letter would be easily pronounced after this sound: this function checks if the that second letter is one of them
    
    Parameters:
    
    c - The second letter of a word beginning with 's'
    
    Returns:
    
    true if the word can be lenited
  - lenite
```
public static String lenite(String in)
```
    lenites a word ("Lenition" in Irish grammar is an initial mutation, historically related to phonetic lenition; its written representation is an 'h' after the initial consonant). In this context, to "lenite" is to apply lenition)
    
    Parameters:
    
    in - word form to be lenited
    
    Returns:
    
    lenited form, or unmodified string if it cannot be lenited
  - eclipse
```
public static String eclipse(String in)
```
    eclipses a word ("Eclipsis" in Irish grammar is an initial mutation, represented as a prefix to the word that replaces the pronunciation of the letter for consonants, i.e., 'f' is eclipsed as 'bh' - 'focal' becomes 'bhfocal' - but only 'bh' (not 'f') is pronounced; or, with vowels, an initial 'n' is added (hyphenated before a lowercase word, lowercased but not hyphenated before an uppercase or titlecase word). In this context, to "eclipse" is to apply eclipsis)
    
    Parameters:
    
    in - word form to be eclipsed
    
    Returns:
    
    eclipsed form, or unmodified string if it cannot be eclipsed
  - toLowerCaseIrish
```
public static String toLowerCaseIrish(String s)
```
    Case folding in Irish is non-trivial: initial mutations that prefix the word are always written in lowercase; 'n' and 't' are written with a hyphen before a lowercase vowel. Converting to uppercase is impossible without a dictionary: unlike 'n' and 't' (and unlike Scots Gaelic), 'h' is not written hyphenated as 'h' was not traditionally a 'letter', per se, but was used to indicate phonetic changes: in modern Irish, there are enough words that begin with 'h' that converting to uppercase is impossible without a dictionary.
    
    Parameters:
    
    s - the word to lowercase
    
    Returns:
    
    lowercased word
  - startsWithUppercase
```
public static boolean startsWithUppercase(String s)
```
    Equivalent of StringTools.startsWithUppercase(String), adapted for Irish case folding oddities.
    
    Parameters:
    
    s - String to check
    
    Returns:
    
    true if string starts with uppercase, taking into account initial mutations which must remain lowercase.
  - isAllUppercase
```
public static boolean isAllUppercase(String s)
```
  - isPonc
```
public static boolean isPonc(char c)
```
    Check if the character is dotted ('ponc' in Irish)
    
    Parameters:
    
    c - the character to check
    
    Returns:
    
    true if the character is dotted, false otherwise
  - containsPonc
```
public static boolean containsPonc(String s)
```
  - unPonc
```
public static String unPonc(String s)
```
    Converts pre-standard lenition to modern (converts dotted (= ponc) letters to the equivalent undotted, followed by 'h'
    
    Parameters:
    
    s - string to convert
    
    Returns:
    
    converted string
  - isAllMathsChars
```
public static boolean isAllMathsChars(String s)
```
  - isAllHalfWidthChars
```
public static boolean isAllHalfWidthChars(String s)
```
  - halfwidthLatinToLatin
```
public static String halfwidthLatinToLatin(String s)
```
  - simplifyMathematical
```
public static String simplifyMathematical(String s)
```
  - simplifyMathematical
```
public static String simplifyMathematical(String s,
                                          boolean normaliseGreek,
                                          boolean normaliseDigits)
```
  - greekToLatin
```
public static String greekToLatin(String s)
```
  - hasMixedGreekAndLatin
```
public static boolean hasMixedGreekAndLatin(String s)
```
  - hasMixedGreekAndCyrillic
```
public static boolean hasMixedGreekAndCyrillic(String s)
```

Class Utils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Utils

Method Detail

fixSuffix

morphWord

demutate

unEclipse

unLenite

unLeniteDefiniteS

unEclipseF

unEclipseChar

isUpperVowel

isLowerVowel

isVowel

isUpperLenitable

isLowerLenitable

isSLenitable

lenite

eclipse

toLowerCaseIrish

startsWithUppercase

isAllUppercase

isPonc

containsPonc

unPonc

isAllMathsChars

isAllHalfWidthChars

halfwidthLatinToLatin

simplifyMathematical

simplifyMathematical

greekToLatin

hasMixedGreekAndLatin

hasMixedGreekAndCyrillic