Version (Nuiton Utils 3.0-rc-6 API)

java.lang.Object
- org.nuiton.util.version.Version

All Implemented Interfaces:

Serializable, Comparable<Version>
```
public class Version
extends Object
implements Comparable<Version>, Serializable
```
A class to represent a version.
Replace previously org.nuiton.util.Version class.
Definition
A version is defined of n componants separated by componantSeparator.
Componants
Componants can be of two types:
- Number componant: a strict positive integer value
- String componant: a sequence of characters which can't be either number nor componant separators
Componant separators
Componant separator are characters which can't be alphanumeric and can be empty character.
Componant separators are optional and componants will be detected as soon as a character changed from a numeric string sequence to a alpha (none numeric!) sequence. For example, version 1a2 is composed of three componants: {code 1}, a and 3.
Snapshot flag
Additionnaly version can be qualifed as a SNAPSHOT (see below section about ordering).
```
  0 (one componant 0)
  0-SNAPSHOT (one componant 0 + SNAPSHOT flag)
  1.0 (two componants 1,0)
  1.1 (two componants 1,1)
  1.1-alpha-1 (four componants 1,1,alpha,1)
  1.1-beta (three componants 1,1,beta)
  1.1-rc-1 (four componants 1,1,rc,1)
  1.1-a  (three componants 1,1,a)
  1.1-a12-4.45_6432 (seven componants 1,1,a,12,4,45,643)
 
```
Ordering
A version is comparable, to have all the detail of order see VersionComparator.
Immutability
The version is immutable, to create or modify a version, use the VersionBuilder API or the internal methods
Since:

3.0

Author:

tchemit

See Also:
VersionBuilder, VersionComparator, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Version.NumberVersionComponant`
`static class`	`Version.StringVersionComponant`
`static interface`	`Version.VersionComponant<C extends Comparable<C>,V extends Version.VersionComponant>`

Field Summary

Fields
Modifier and Type	Field and Description
`protected List<Version.VersionComponant>`	`componants` List of componants of the version.
`protected List<String>`	`componantSeparators` List of separators of the version.
`static char`	`DEFAULT_JOIN_COMPONANT_SEPARATOR`
`protected boolean`	`snapshot` flag to define if version is a snapshot (if so a -SNAPSHOT is added at the end of the textual representation of the version).
`static String`	`SNAPSHOT_SUFFIX` Suffix of a `SNAPSHOT` version in the text representation.
`protected String`	`version` string represention of the version.
`protected static VersionComparator`	`VERSION_COMPARATOR` Comparator of version used internaly to fulfill the compoarator contract.
`static Version`	`VZERO` Version V0.

Constructor Summary

Constructors
Modifier Constructor and Description

protected Version(List<Version.VersionComponant> componants, List<String> componantSeparators, boolean snapshot)

Constructors
Modifier	Constructor and Description
`protected`	`Version(List<Version.VersionComponant> componants, List<String> componantSeparators, boolean snapshot)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`after(Version o)`
`boolean`	`before(Version o)`
`int`	`compareTo(Version o)`
`Version`	`decrements(int componantPosition)` Creates a new version from this one with the number componant decremented at the given position.
`boolean`	`equals(Object o)`
`String`	`getClassifierComponant(int componantPosition)`
`protected Version.VersionComponant`	`getComponant(int level)`
`int`	`getComponantCount()`
`List<Version.VersionComponant>`	`getComponants()`
`List<String>`	`getComponantSeparators()`
`protected Version.VersionComponant`	`getLastComponant()`
`int`	`getNumberComponant(int componantPosition)`
`String`	`getValidName()` Convert the string representation to a java identifier compliant.
`String`	`getVersion()`
`int`	`hashCode()`
`Version`	`increments()` Creates a new version from this one incremented.
`Version`	`increments(char componantSeperator)` Creates a new version from this one incremented.
`Version`	`increments(int componantPosition)` Creates a new version from this one with the number componant incremented at the given position.
`boolean`	`isSnapshot()`
`String`	`toString()`

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

- Field Detail
  - SNAPSHOT_SUFFIX
```
public static final String SNAPSHOT_SUFFIX
```
    Suffix of a SNAPSHOT version in the text representation.
    
    See Also:
    Constant Field Values
  - VZERO
```
public static final Version VZERO
```
    Version V0.
  - VERSION_COMPARATOR
```
protected static final VersionComparator VERSION_COMPARATOR
```
    Comparator of version used internaly to fulfill the compoarator contract.
  - DEFAULT_JOIN_COMPONANT_SEPARATOR
```
public static final char DEFAULT_JOIN_COMPONANT_SEPARATOR
```
    See Also:
    Constant Field Values
  - componants
```
protected final List<Version.VersionComponant> componants
```
    List of componants of the version.
  - componantSeparators
```
protected final List<String> componantSeparators
```
    List of separators of the version.
  - snapshot
```
protected final boolean snapshot
```
    flag to define if version is a snapshot (if so a -SNAPSHOT is added at the end of the textual representation of the version).
  - version
```
protected transient String version
```
    string represention of the version.
- Constructor Detail
  - Version
```
protected Version(List<Version.VersionComponant> componants,
       List<String> componantSeparators,
       boolean snapshot)
```
- Method Detail
  - getComponants
```
public List<Version.VersionComponant> getComponants()
```
  - getComponantSeparators
```
public List<String> getComponantSeparators()
```
  - isSnapshot
```
public boolean isSnapshot()
```
  - getComponantCount
```
public int getComponantCount()
```
  - getNumberComponant
```
public int getNumberComponant(int componantPosition)
```
  - getClassifierComponant
```
public String getClassifierComponant(int componantPosition)
```
  - getVersion
```
public String getVersion()
```
    Returns:
    the string represention value of the version
  - getValidName
```
public String getValidName()
```
    Convert the string representation to a java identifier compliant.
    - in java: . is forbidden
    - in database (mysql, h2 ...): . is forbidden
    Forbidden values are replaced by _ character.
    Returns:
    the java compilant string representation of the version
  - increments
```
public Version increments()
```
    Creates a new version from this one incremented.
    If the last componant is a number, then just increments this number; otherwise add a new number componant with value 1.
    Example:
    - 1 -> 2
    - 1-a -> 1-a.1
    Returns:
    the incremented version
  - increments
```
public Version increments(char componantSeperator)
```
    Creates a new version from this one incremented.
    If the last componant is a number, then just increments this number; otherwise add a new number componant with value 1.
    Example:
    - 1 -> 2
    - 1-a -> 1-a.1
    Parameters:
    componantSeperator - the componant separator to use the last componant is a classifier
    
    Returns:
    the incremented version
  - increments
```
public Version increments(int componantPosition)
```
    Creates a new version from this one with the number componant incremented at the given position.
    Note: Will fail if the componant at the required position is not a number.
    
    Parameters:
    componantPosition - position of the version componant to increment
    
    Returns:
    the incremented version
  - decrements
```
public Version decrements(int componantPosition)
```
    Creates a new version from this one with the number componant decremented at the given position.
    Note: Will fail if the componant at the required position is not a number, or his value is 0.
    
    Parameters:
    componantPosition - position of the version componant to increment
    
    Returns:
    the decremented version
  - compareTo
```
public int compareTo(Version o)
```
    Specified by:
    
    compareTo in interface Comparable<Version>
  - before
```
public boolean before(Version o)
```
    Parameters:
    o - the other version to test
    
    Returns:
    true if current version is before the given one
  - after
```
public boolean after(Version o)
```
    Parameters:
    o - the other version to test
    
    Returns:
    true if current version is after the given one
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getComponant
```
protected Version.VersionComponant getComponant(int level)
```
  - getLastComponant
```
protected Version.VersionComponant getLastComponant()
```

Class Version

Definition

Componants

Componant separators

Snapshot flag

Ordering

Immutability

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SNAPSHOT_SUFFIX

VZERO

VERSION_COMPARATOR

DEFAULT_JOIN_COMPONANT_SEPARATOR

componants

componantSeparators

snapshot

version

Constructor Detail

Version

Method Detail

getComponants

getComponantSeparators

isSnapshot

getComponantCount

getNumberComponant

getClassifierComponant

getVersion

getValidName

increments

increments

increments

decrements

compareTo

before

after

toString

equals

hashCode

getComponant

getLastComponant