DiacriticalMark (JavaDocs for mmm-all dev-SNAPSHOT)

java.lang.Object
- java.lang.Enum<DiacriticalMark>
- - net.sf.mmm.util.text.api.DiacriticalMark

All Implemented Interfaces:

Serializable, Comparable<DiacriticalMark>, AttributeReadValue<Character>, Datatype, SimpleDatatype<Character>
```
public enum DiacriticalMark
extends Enum<DiacriticalMark>
implements SimpleDatatype<Character>
```
This enum contains the most important diacritical marks.
If you are NOT familiar with unicode and languages that use non-ASCII characters, you should know that each DiacriticalMark represents a specific shape like e.g. '~', '^', etc. that is added at a specific position (on top, at bottom, etc.) to a letter. For instance if you add two dots to the letter 'a' you get 'ä'.
To make things really complicated, unicode added combining characters representing the mark itself in addition to the precomposed characters (combination of a specific character with the mark[s]).
ATTENTION:
The unicode standard is extremely complex and sometimes it appears inconsistent in the first place. E.g. there are combining characters that have no equivalent separate character. Further the naming of composed characters in the unicode standard are not always precise enough to determine the according combining character. E.g. UnicodeUtil.LATIN_SMALL_LETTER_DOTLESS_J_WITH_STROKE and UnicodeUtil.LATIN_SMALL_LETTER_O_WITH_STROKE could be considered to be both a combination of the diacritic "stroke". However, observing the glyphs and studying unicode indicated that this is wrong.
Therefore this class and also UnicodeUtil should be considered as work in progress and we heavily require your contribution to improve and support more diacritics. It may also be possible that characters or diacritics get renamed in future versions if our understanding of unicode grows.

Since:

2.0.0

Author:

Joerg Hohwiller (hohwille at users.sourceforge.net)

See Also:

Normalizer

Enum Constant Summary

Enum Constants
Enum Constant and Description
`ACUTE` A mark that can be placed on top of some Latin, Cyrillic or Greek characters.
`BREVE` A mark that can be placed on top of some Latin, ...
`CARON` A mark that can be placed on top of some Latin, ...
`CEDILLA` A mark that can be placed at the bottom of some Latin characters.
`CIRCUMFLEX` A mark that can be placed on top of some Latin characters (e.g.
`DIAERESIS` Two small dots placed on top of Latin vowels, called trema, diaeresis, or umlaut.
`DOT_ABOVE` A small dot placed to the top of some Latin letters used in some European languages and Vietnamese.
`DOT_BELOW` A small dot placed to the bottom of some Latin letters used in some European languages and Vietnamese.
`DOUBLE_ACUTE` Like `ACUTE` but doubled.
`DOUBLE_GRAVE` Like `GRAVE` but doubled.
`GRAVE` A mark that can be placed on top of some Latin, Cyrillic or Greek characters.
`HOOK_ABOVE` A little question mark without the dot, that is placed on top of Vietnamese letters.
`HORN_ABOVE` A mark similar to a comma (,) that is placed to the top right of Vietnamese vowels.
`MACRON` A long horizontal stroke placed on top of letters.
`OGONEK` A little hook placed to the bottom right of Latin vowels.
`RING_ABOVE` A small ring placed to the top of some Latin letters.
`SHORT_SOLIDUS_OVERLAY` A short solidus is a line diagonal through a grapheme (letter).
`SHORT_STROKE_OVERLAY` A short stroke is a short line drawn horizontal through a grapheme (letter).
`TILDE` A small tilde (~) placed on top of some letters.

Field Summary

Fields
Modifier and Type	Field and Description
`private char`	`combiningCharacter`
`private Collection<Character>`	`composedCharacters`
`private Map<Character,Character>`	`composeMap`
`private Map<Character,Character>`	`decomposeMap`
`private char`	`separateCharacter`
`private String`	`title`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addComposition(char uncomposed, char composed)` This method adds the given `composition` pair.
`Character`	`compose(char character)` This method composes the given `character` with this `DiacriticalMark`.
`Character`	`decompose(char character)` This method de-composes the given `character` with this `DiacriticalMark`.
`char`	`getCombiningCharacter()` This method gets the combining character for this `DiacriticalMark`.
`Collection<Character>`	`getComposedCharacters()` This method gets a `Collection` with all precomposed `characters` containing this mark.
`char`	`getSeparateCharacter()` This method gets the separate character for this `DiacriticalMark`.
`Character`	`getValue()` This method returns the raw value of this datatype.
`protected abstract void`	`initialize()` This method is called at construction.
`String`	`toString()` Returns the official `String` representation of this `Datatype`.
`static DiacriticalMark`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static DiacriticalMark[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Enum Constant Detail
  - ACUTE
```
public static final DiacriticalMark ACUTE
```
    A mark that can be placed on top of some Latin, Cyrillic or Greek characters. It looks like a stroke directing to the upper right corner. If your environment supports unicode, you can see it here: ´
  - BREVE
```
public static final DiacriticalMark BREVE
```
    A mark that can be placed on top of some Latin, ... characters. It looks like an arc as the lower third of a circle. the If your environment supports unicode, you can see it here: ˘
  - CARON
```
public static final DiacriticalMark CARON
```
    A mark that can be placed on top of some Latin, ... characters. It looks like a little 'v'. If your environment supports unicode, you can see it here: ˇ
  - CEDILLA
```
public static final DiacriticalMark CEDILLA
```
    A mark that can be placed at the bottom of some Latin characters. If your environment supports unicode, you can see it here: ¸
  - CIRCUMFLEX
```
public static final DiacriticalMark CIRCUMFLEX
```
    A mark that can be placed on top of some Latin characters (e.g. in French). It looks like a small '^'. If your environment supports unicode, you can see it here: ̂
  - DIAERESIS
```
public static final DiacriticalMark DIAERESIS
```
    Two small dots placed on top of Latin vowels, called trema, diaeresis, or umlaut. If your environment supports unicode, you can see it here: ¨
  - DOT_ABOVE
```
public static final DiacriticalMark DOT_ABOVE
```
    A small dot placed to the top of some Latin letters used in some European languages and Vietnamese. If your environment supports unicode, you can see it here: ˙
  - DOT_BELOW
```
public static final DiacriticalMark DOT_BELOW
```
    A small dot placed to the bottom of some Latin letters used in some European languages and Vietnamese. If your environment supports unicode, you can see it here: ̣
  - DOUBLE_ACUTE
```
public static final DiacriticalMark DOUBLE_ACUTE
```
    Like ACUTE but doubled. If your environment supports unicode, you can see it here: ˝
  - DOUBLE_GRAVE
```
public static final DiacriticalMark DOUBLE_GRAVE
```
    Like GRAVE but doubled. If your environment supports unicode, you can see it here: ̏ .
  - GRAVE
```
public static final DiacriticalMark GRAVE
```
    A mark that can be placed on top of some Latin, Cyrillic or Greek characters. It looks like a stroke directing to the lower right. If your environment supports unicode, you can see it here: `
  - HOOK_ABOVE
```
public static final DiacriticalMark HOOK_ABOVE
```
    A little question mark without the dot, that is placed on top of Vietnamese letters. If your environment supports unicode, you can see it here: ϒ ɓ
  - HORN_ABOVE
```
public static final DiacriticalMark HORN_ABOVE
```
    A mark similar to a comma (,) that is placed to the top right of Vietnamese vowels. If your environment supports unicode, you can see it here: ̛
  - MACRON
```
public static final DiacriticalMark MACRON
```
    A long horizontal stroke placed on top of letters. If your environment supports unicode, you can see it here: ¯
  - OGONEK
```
public static final DiacriticalMark OGONEK
```
    A little hook placed to the bottom right of Latin vowels. If your environment supports unicode, you can see it here: ˛
  - RING_ABOVE
```
public static final DiacriticalMark RING_ABOVE
```
    A small ring placed to the top of some Latin letters. If your environment supports unicode, you can see it here: ˚
  - SHORT_SOLIDUS_OVERLAY
```
public static final DiacriticalMark SHORT_SOLIDUS_OVERLAY
```
    A short solidus is a line diagonal through a grapheme (letter). You can think of it as a slash.
  - SHORT_STROKE_OVERLAY
```
public static final DiacriticalMark SHORT_STROKE_OVERLAY
```
    A short stroke is a short line drawn horizontal through a grapheme (letter).
  - TILDE
```
public static final DiacriticalMark TILDE
```
    A small tilde (~) placed on top of some letters. If your environment supports unicode, you can see it here: ~
- Field Detail
  - separateCharacter
```
private final char separateCharacter
```
  - combiningCharacter
```
private final char combiningCharacter
```
  - title
```
private final String title
```
  - composeMap
```
private final Map<Character,Character> composeMap
```
  - decomposeMap
```
private final Map<Character,Character> decomposeMap
```
  - composedCharacters
```
private final Collection<Character> composedCharacters
```
- Method Detail
  - values
```
public static DiacriticalMark[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (DiacriticalMark c : DiacriticalMark.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static DiacriticalMark valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - initialize
```
protected abstract void initialize()
```
    This method is called at construction.
  - addComposition
```
protected void addComposition(char uncomposed,
                              char composed)
```
    This method adds the given composition pair.
    
    Parameters:
    
    uncomposed - is the uncomposed character.
    
    composed - is the composed character.
  - getSeparateCharacter
```
public char getSeparateCharacter()
```
    This method gets the separate character for this DiacriticalMark. It represents the mark itself as a standalone character.
    ATTENTION:
    For an unknown reason unicode does NOT define a proper separate character for each diacritic or for each combining character. Therefore this method may return a character that looks similar to the diacritic mark, but is NOT the correct representation for it.
    
    Returns:
    
    the separate character.
    
    See Also:
    
    getCombiningCharacter()
  - getCombiningCharacter
```
public char getCombiningCharacter()
```
    This method gets the combining character for this DiacriticalMark. Unlike the separate character this character gets combined with the following character to a single glyph.
    
    Returns:
    
    the combining character.
  - getValue
```
public Character getValue()
```
    Description copied from interface: SimpleDatatype
    
    This method returns the raw value of this datatype. This will typically be a standard datatype (like String , Character, Boolean, any type of Number, any type of java.time.LocalDate, etc.).
    
    Specified by:
    
    getValue in interface AttributeReadValue<Character>
    
    Specified by:
    
    getValue in interface SimpleDatatype<Character>
    
    Returns:
    
    the value of this datatype.
  - compose
```
public Character compose(char character)
```
    This method composes the given character with this DiacriticalMark.
    
    Parameters:
    
    character - is the character to compose (e.g. 'a').
    
    Returns:
    
    the composed character (e.g. 'ä' or 'á') or null if no such composition exists in unicode.
  - decompose
```
public Character decompose(char character)
```
    This method de-composes the given character with this DiacriticalMark. In other words this DiacriticalMark is removed from the given character if it is composed. It is the inverse operation of compose(char).
    
    Parameters:
    
    character - is the character to de-compose (e.g. 'ä' or 'á').
    
    Returns:
    
    the de-composed character (e.g. 'a') or null if the given character does is not composed with this DiacriticalMark.
  - getComposedCharacters
```
public Collection<Character> getComposedCharacters()
```
    This method gets a Collection with all precomposed characters containing this mark.
    
    Returns:
    
    the composed characters.
  - toString
```
public String toString()
```
    Description copied from interface: Datatype
    
    Returns the official String representation of this Datatype. While the general contract of Object.toString() is very weak and mainly used for debugging, the contract here is very strong. The returned String has to be suitable for end-users and official output to any kind of sink.
    ATTENTION:
    This method is not supposed to do internationalization (I18N). See NlsMessage for this purpose and implement NlsObject if you want to support I18N/L10N.
    
    Specified by:
    
    toString in interface Datatype
    
    Overrides:
    
    toString in class Enum<DiacriticalMark>
    
    Returns:
    
    the official String representation to display the value of this Datatype.

Enum DiacriticalMark

Enum Constant Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

ACUTE

BREVE

CARON

CEDILLA

CIRCUMFLEX

DIAERESIS

DOT_ABOVE

DOT_BELOW

DOUBLE_ACUTE

DOUBLE_GRAVE

GRAVE

HOOK_ABOVE

HORN_ABOVE

MACRON

OGONEK

RING_ABOVE

SHORT_SOLIDUS_OVERLAY

SHORT_STROKE_OVERLAY

TILDE

Field Detail

separateCharacter

combiningCharacter

title

composeMap

decomposeMap

composedCharacters

Method Detail

values

valueOf

initialize

addComposition

getSeparateCharacter

getCombiningCharacter

getValue

compose

decompose

getComposedCharacters

toString