DotName (Jandex: Core 3.0.1 API)

java.lang.Object
- org.jboss.jandex.DotName

All Implemented Interfaces:

Comparable<DotName>
```
public final class DotName
extends Object
implements Comparable<DotName>
```
A DotName represents a dot separated name, typically a Java package or a Java class. It has two possible variants. A simple wrapper based variant allows for fast construction (it simply wraps the specified name string). Whereas, a componentized variant represents one or more String components that, when combined with a dot character, assemble the full name. The intention of the componentized variant is that the String components can be reused to offer memory efficiency. This reuse is common in Java where packages and classes follow a tree structure.
Both the simple and componentized variants are considered semantically equivalent if they refer to the same logical name. More specifically, the equals and hashCode methods return the same values for the same semantic name regardless of the variant used. Which variant to use when depends on the specific performance and overhead objectives of the specific use pattern.
Simple names are cheap to construct (just an additional wrapper object), so are ideal for temporary use, like looking for an entry in a Map. Componentized names however require that they be split in advance, and so require some additional time to construct. However, the memory benefits of reusing component strings make them desirable when stored in a longer term area such as in a Java data structure.

Author:

Jason T. Greene

Field Summary

Fields
Modifier and Type Field and Description

static DotName ENUM_NAME

static DotName OBJECT_NAME

static DotName RECORD_NAME

static DotName STRING_NAME

Fields
Modifier and Type	Field and Description
`static DotName`	`ENUM_NAME`
`static DotName`	`OBJECT_NAME`
`static DotName`	`RECORD_NAME`
`static DotName`	`STRING_NAME`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareTo(DotName other)` Compares a `DotName` to another `DotName` and returns whether this `DotName` is lesser than, greater than, or equal to the specified DotName.
`static DotName`	`createComponentized(DotName prefix, String localName)` Constructs a componentized `DotName`.
`static DotName`	`createComponentized(DotName prefix, String localName, boolean innerClass)` Constructs a componentized `DotName`.
`static DotName`	`createSimple(Class<?> clazz)` Constructs a simple `DotName` which stores the name of given class in its entirety.
`static DotName`	`createSimple(String name)` Constructs a simple `DotName` which stores the string in its entirety.
`boolean`	`equals(Object o)` Compares a `DotName` to another `DotName` and returns `true` if they represent the same underlying semantic name.
`int`	`hashCode()` Returns a hash code which is based on the semantic representation of this `DotName`.
`boolean`	`isComponentized()` Returns whether this `DotName` is a componentized variant.
`boolean`	`isInner()` Returns whether the local portion of a componentized `DotName` is separated by an inner class style delimiter (`'$'`).
`String`	`local()` Returns the local portion of this `DotName`.
`String`	`packagePrefix()` Returns the package portion of this `DotName`.
`DotName`	`packagePrefixName()` Returns the package portion of this `DotName`.
`DotName`	`prefix()` Returns the parent prefix for this `DotName` or `null` if there is none.
`String`	`toString()` Returns the regular fully qualifier class name.
`String`	`toString(char delim)`
`String`	`withoutPackagePrefix()` Returns the portion of this `DotName` that does not contain a package prefix.

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

- Field Detail
  - OBJECT_NAME
```
public static final DotName OBJECT_NAME
```
  - ENUM_NAME
```
public static final DotName ENUM_NAME
```
  - RECORD_NAME
```
public static final DotName RECORD_NAME
```
  - STRING_NAME
```
public static final DotName STRING_NAME
```
- Method Detail
  - createSimple
```
public static DotName createSimple(String name)
```
    Constructs a simple DotName which stores the string in its entirety. This variant is ideal for temporary usage, such as looking up an entry in a Map or an index.
    
    Parameters:
    
    name - a fully qualified name (with dots); must not be null
    
    Returns:
    
    a simple DotName that wraps given name; never null
  - createSimple
```
public static DotName createSimple(Class<?> clazz)
```
    Constructs a simple DotName which stores the name of given class in its entirety. This variant is ideal for temporary usage, such as looking up an entry in a Map or an index.
    This method is a shortcut for DotName.createSimple(clazz.getName()).
    
    Parameters:
    
    clazz - a class whose fully qualified name is returned; must not be null
    
    Returns:
    
    a simple DotName that wraps the name of given clazz; never null
  - createComponentized
```
public static DotName createComponentized(DotName prefix,
                                          String localName)
```
    Constructs a componentized DotName. Such DotName refers to a parent prefix (or null if there is no further prefix) in addition to a local name that has no dot separator. The fully qualified name this DotName represents is constructed by recursing all parent prefixes and joining all local names with the '.' character.
    
    Parameters:
    
    prefix - another DotName that is the portion of the final name to the left of localName; may be null if there is no prefix
    
    localName - the local portion of this name; must not be null and must not contain '.'
    
    Returns:
    
    a componentized DotName; never null
  - createComponentized
```
public static DotName createComponentized(DotName prefix,
                                          String localName,
                                          boolean innerClass)
```
    Constructs a componentized DotName. Such DotName refers to a parent prefix (or null if there is no further prefix) in addition to a local name that has no dot separator. The fully qualified name this DotName represents is constructed by recursing all parent prefixes and joining all local names with the '.' character.
    
    Parameters:
    
    prefix - another DotName that is the portion of the final name to the left of localName; may be null if there is no prefix
    
    localName - the local portion of this name; must not be null and must not contain '.'
    
    innerClass - whether the localName is an inner class style name, which is joined to the prefix using '$' instead of '.'
    
    Returns:
    
    a componentized DotName; never null
  - prefix
```
public DotName prefix()
```
    Returns the parent prefix for this DotName or null if there is none. Simple DotName variants never have a prefix.
    
    Returns:
    
    the parent prefix for this DotName; may be null
  - local
```
public String local()
```
    Returns the local portion of this DotName. In simple variants, the entire fully qualified string is returned. In componentized variants, just the rightmost portion not including a separator (either '.' or '$') is returned.
    Use withoutPackagePrefix() instead of this method if the desired value is the part of the string (including '$' signs if present) after the rightmost '.' delimiter.
    
    Returns:
    
    the local portion of this DotName; never null
  - withoutPackagePrefix
```
public String withoutPackagePrefix()
```
    Returns the portion of this DotName that does not contain a package prefix. In the case of an inner class syntax name, the '$' portion is included in the return value.
    
    Returns:
    
    the portion of the fully qualified name that does not include a package name
    
    Since:
    
    2.1.1
  - packagePrefix
```
public String packagePrefix()
```
    Returns the package portion of this DotName.
    
    Returns:
    
    the package name or null if this DotName has no package prefix
    
    Since:
    
    2.4
  - packagePrefixName
```
public DotName packagePrefixName()
```
    Returns the package portion of this DotName. This is a DotName-returning variant of packagePrefix().
    
    Returns:
    
    the package name or null if this DotName has no package prefix
    
    Since:
    
    3.0
  - isComponentized
```
public boolean isComponentized()
```
    Returns whether this DotName is a componentized variant.
    
    Returns:
    
    true if it is componentized, false if it is a simple DotName
  - isInner
```
public boolean isInner()
```
    Returns whether the local portion of a componentized DotName is separated by an inner class style delimiter ('$'). The result is undefined when this DotName is not componentized.
    This should not be used to test whether the name truly refers to an inner class, only that the dollar sign delimits the value. Java class names are allowed to contain '$' signs, so the local value could simply be a fragment of a class name, and not an actual inner class. The correct way to determine whether a name refers to an actual inner class is to look up a ClassInfo in the index and examine the nesting type like so:
```
 index.getClassByName(name).nestingType() != TOP_LEVEL;
 
```
    Returns:
    
    true if local is an inner class style delimited name, false otherwise
  - toString
```
public String toString()
```
    Returns the regular fully qualifier class name.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    The fully qualified class name
  - toString
```
public String toString(char delim)
```
  - hashCode
```
public int hashCode()
```
    Returns a hash code which is based on the semantic representation of this DotName.
    Whether a DotName is componentized has no impact on the calculated hash code. In other words, a componentized DotName and a simple DotName that represent the same fully qualified name have the same hash code.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    a hash code representing this object
    
    See Also:
    
    Object.hashCode()
  - compareTo
```
public int compareTo(DotName other)
```
    Compares a DotName to another DotName and returns whether this DotName is lesser than, greater than, or equal to the specified DotName. If this DotName is lesser, a negative value is returned. If greater, a positive value is returned. If equal, zero is returned.
    
    Specified by:
    
    compareTo in interface Comparable<DotName>
    
    Parameters:
    
    other - the DotName to compare to
    
    Returns:
    
    a negative number if this is less than the specified object, a positive if greater, and zero if equal
    
    See Also:
    
    Comparable.compareTo(Object)
  - equals
```
public boolean equals(Object o)
```
    Compares a DotName to another DotName and returns true if they represent the same underlying semantic name. In other words, whether a name is componentized or simple has no bearing on the comparison.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - the DotName object to compare to
    
    Returns:
    
    true if equal, false if not
    
    See Also:
    
    Object.equals(Object)

Class DotName

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

OBJECT_NAME

ENUM_NAME

RECORD_NAME

STRING_NAME

Method Detail

createSimple

createSimple

createComponentized

createComponentized

prefix

local

withoutPackagePrefix

packagePrefix

packagePrefixName

isComponentized

isInner

toString

toString

hashCode

compareTo

equals