Version (GemFire XD Java API Documentation)

java.lang.Object
- com.gemstone.gemfire.internal.shared.Version

All Implemented Interfaces:

Comparable<Version>
```
public final class Version
extends Object
implements Comparable<Version>
```
Enumerated type for client / server and p2p version. There are dependencies in versioning code that require newer versions to have ordinals higher than older versions in order to protect against deserialization problems. Client/server code also uses greater-than comparison of ordinals in backward-compatibility checks.

Since:

5.7

Field Summary

Fields
Modifier and Type	Field and Description
`static Version`	`CURRENT` This constant must be set to the most current version of GFE/GFXD.
`static short`	`CURRENT_ORDINAL` A lot of versioning code needs access to the current version's ordinal
`static Version`	`GFE_56`
`static Version`	`GFE_57`
`static Version`	`GFE_58`
`static Version`	`GFE_603`
`static Version`	`GFE_61`
`static Version`	`GFE_65`
`static Version`	`GFE_651`
`static Version`	`GFE_6516`
`static Version`	`GFE_66`
`static Version`	`GFE_662`
`static Version`	`GFE_6622`
`static Version`	`GFE_70`
`static Version`	`GFE_701`
`static Version`	`GFE_7099` This is the GemFire conterpart of GFXD_1099 for testing rolling upgrades and it uses the same ordinal as GFE_701 to maintain compatibility with the ordinals being used on GemFireXD branch.
`static Version`	`GFE_71`
`static Version`	`GFE_75`
`static Version`	`GFXD_10`
`static Version`	`GFXD_101`
`static Version`	`GFXD_1011`
`static Version`	`GFXD_13`
`static Version`	`GFXD_1302`
`static Version`	`GFXD_14`
`static Version`	`GFXD_20`
`static short`	`NOT_SUPPORTED_ORDINAL`
`static int`	`NUM_OF_VERSIONS`
`static Version`	`SQLF_1099` This version is an intermediate one created to test rolling upgrades.
`static Version`	`SQLF_11` SQLFire 1.1 has a separate version since it has changed the RowFormatter formatting for ALTER TABLE add/drop column support.
`static Version`	`TEST_VERSION`
`static Version`	`TOKEN`
`static String`	`Version_REMOTE_VERSION_NOT_SUPPORTED`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`compareTo(short other)` Finds the Version instance corresponding to the given ordinal and returns the result of compareTo(Version)
`int`	`compareTo(Version o)`
`boolean`	`compatibleWith(Version version)` Returns whether this `Version` is compatible with the input `Version`
`int`	`compressedSize()` Fixed number of bytes required for serializing this version when "compressed" flag is true in `writeOrdinal(DataOutput, boolean)`.
`boolean`	`equals(Object other)`
`boolean`	`equals(Version other)`
`static Version`	`fromBytes(byte[] bytes)`
`static Version`	`fromOrdinal(short ordinal, boolean forGFEClients)` Return the `Version` represented by specified ordinal
`static Version`	`fromOrdinalCheck(short ordinal, boolean returnNullForCurrent)` Return the `Version` represented by specified ordinal while not throwing exception if given ordinal is higher than any known ones.
`static Version`	`fromOrdinalOrCurrent(short ordinal)` return the version corresponding to the given ordinal, or CURRENT if the ordinal isn't valid
`Version`	`getGemFireVersion()`
`short`	`getMajorVersion()`
`String`	`getMethodSuffix()`
`short`	`getMinorVersion()`
`String`	`getName()`
`short`	`getPatch()`
`String`	`getProductName()`
`short`	`getRelease()`
`int`	`hashCode()`
`short`	`ordinal()`
`static short`	`readOrdinal(DataInput in)` Reads ordinal as written by `writeOrdinal(java.io.DataOutput, short, boolean)` from given `DataInput`.
`static short`	`readOrdinalFromInputStream(InputStream is)` Reads ordinal as written by `writeOrdinal(java.io.DataOutput, short, boolean)` from given `InputStream`.
`static Version`	`readVersion(DataInput in, boolean returnNullForCurrent)` Return the `Version` reading from given `DataInput` as serialized by `writeOrdinal(DataOutput, boolean)`.
`byte[]`	`toBytes()`
`String`	`toString()` Returns a string representation for this `Version`.
`static String`	`toString(short ordinal)`
`static int`	`uncompressedSize()` Fixed number of bytes required for serializing this version when "compressed" flag is false in `writeOrdinal(DataOutput, boolean)`.
`static void`	`writeOrdinal(ByteBuffer buffer, short ordinal, boolean compressed)` Write the given ordinal (result of `ordinal()`) to given `ByteBuffer`.
`void`	`writeOrdinal(DataOutput out, boolean compressed)` Write this `Version`'s ordinal (result of `ordinal()`) to given `DataOutput`.
`static void`	`writeOrdinal(DataOutput out, short ordinal, boolean compressed)` Write the given ordinal (result of `ordinal()`) to given `DataOutput`.

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

- Field Detail
  - Version_REMOTE_VERSION_NOT_SUPPORTED
```
public static final String Version_REMOTE_VERSION_NOT_SUPPORTED
```
    See Also:
    Constant Field Values
  - NUM_OF_VERSIONS
```
public static final int NUM_OF_VERSIONS
```
    See Also:
    Constant Field Values
  - TOKEN
```
public static final Version TOKEN
```
  - GFE_56
```
public static final Version GFE_56
```
  - GFE_57
```
public static final Version GFE_57
```
  - GFE_58
```
public static final Version GFE_58
```
  - GFE_603
```
public static final Version GFE_603
```
  - GFE_61
```
public static final Version GFE_61
```
  - GFE_65
```
public static final Version GFE_65
```
  - GFE_651
```
public static final Version GFE_651
```
  - GFE_6516
```
public static final Version GFE_6516
```
  - GFE_66
```
public static final Version GFE_66
```
  - GFE_662
```
public static final Version GFE_662
```
  - GFE_6622
```
public static final Version GFE_6622
```
  - GFE_70
```
public static final Version GFE_70
```
  - GFE_701
```
public static final Version GFE_701
```
  - SQLF_1099
```
public static final Version SQLF_1099
```
    This version is an intermediate one created to test rolling upgrades. It is compatible with GFXD_11 in all respects except for artifical changes in a couple of P2P messages and marking as compatible with GFE_701.
  - GFE_7099
```
public static final Version GFE_7099
```
    This is the GemFire conterpart of GFXD_1099 for testing rolling upgrades and it uses the same ordinal as GFE_701 to maintain compatibility with the ordinals being used on GemFireXD branch. Ordinals is same as that for GFXD_1099 which is not an issue.
  - SQLF_11
```
public static final Version SQLF_11
```
    SQLFire 1.1 has a separate version since it has changed the RowFormatter formatting for ALTER TABLE add/drop column support. However, its underlying GemFire version will remain at GFE_7x.
  - GFE_71
```
public static final Version GFE_71
```
  - GFE_75
```
public static final Version GFE_75
```
  - GFXD_10
```
public static final Version GFXD_10
```
  - GFXD_101
```
public static final Version GFXD_101
```
  - GFXD_1011
```
public static final Version GFXD_1011
```
  - GFXD_13
```
public static final Version GFXD_13
```
  - GFXD_1302
```
public static final Version GFXD_1302
```
  - GFXD_14
```
public static final Version GFXD_14
```
  - GFXD_20
```
public static final Version GFXD_20
```
  - CURRENT
```
public static final Version CURRENT
```
    This constant must be set to the most current version of GFE/GFXD.
  - CURRENT_ORDINAL
```
public static final short CURRENT_ORDINAL
```
    A lot of versioning code needs access to the current version's ordinal
  - NOT_SUPPORTED_ORDINAL
```
public static final short NOT_SUPPORTED_ORDINAL
```
    See Also:
    Constant Field Values
  - TEST_VERSION
```
public static final Version TEST_VERSION
```
- Method Detail
  - fromOrdinal
```
public static Version fromOrdinal(short ordinal,
                  boolean forGFEClients)
                           throws UnsupportedGFXDVersionException
```
    Return the Version represented by specified ordinal
    
    Throws:
    
    UnsupportedGFXDVersionException
  - fromOrdinalOrCurrent
```
public static Version fromOrdinalOrCurrent(short ordinal)
```
    return the version corresponding to the given ordinal, or CURRENT if the ordinal isn't valid
    
    Parameters:
    ordinal -
    
    Returns:
    the corresponding ordinal
  - writeOrdinal
```
public static void writeOrdinal(DataOutput out,
                short ordinal,
                boolean compressed)
                         throws IOException
```
    Write the given ordinal (result of ordinal()) to given DataOutput. This keeps the serialization of ordinal compatible with previous versions writing a single byte to DataOutput when possible, and a token with 2 bytes if it is large.
    
    Parameters:
    out - the DataOutput to write the ordinal write to
    ordinal - the version to be written
    compressed - if true, then use single byte for ordinal < 128, and three bytes for beyond that, else always use three bytes where the first byte is TOKEN_ORDINAL; former mode is useful for interoperatibility with previous versions while latter to use fixed size for writing version; typically former will be used for P2P/client-server communications while latter for persisting to disk; we use the token to ensure that readOrdinal(DataInput) can deal with both compressed/uncompressed cases seemlessly
    
    Throws:
    
    IOException
  - writeOrdinal
```
public final void writeOrdinal(DataOutput out,
                boolean compressed)
                        throws IOException
```
    Write this Version's ordinal (result of ordinal()) to given DataOutput. This keeps the serialization of ordinal compatible with previous versions writing a single byte to DataOutput when possible, and a token with 2 bytes if it is large.
    
    Parameters:
    out - the DataOutput to write the ordinal write to
    compressed - if true, then use single byte for ordinal < 128, and three bytes for beyond that, else always use three bytes where the first byte is TOKEN_ORDINAL; former mode is useful for interoperatibility with previous versions while latter to use fixed size for writing version; typically former will be used for P2P/client-server communications while latter for persisting to disk; we use the token to ensure that readOrdinal(DataInput) can deal with both compressed/uncompressed cases seemlessly
    
    Throws:
    
    IOException
  - uncompressedSize
```
public static final int uncompressedSize()
```
    Fixed number of bytes required for serializing this version when "compressed" flag is false in writeOrdinal(DataOutput, boolean).
  - compressedSize
```
public final int compressedSize()
```
    Fixed number of bytes required for serializing this version when "compressed" flag is true in writeOrdinal(DataOutput, boolean).
  - writeOrdinal
```
public static void writeOrdinal(ByteBuffer buffer,
                short ordinal,
                boolean compressed)
                         throws IOException
```
    Write the given ordinal (result of ordinal()) to given ByteBuffer. This keeps the serialization of ordinal compatible with previous versions writing a single byte to DataOutput when possible, and a token with 2 bytes if it is large.
    
    Parameters:
    buffer - the ByteBuffer to write the ordinal write to
    ordinal - the version to be written
    compressed - if true, then use single byte for ordinal < 128, and three bytes for beyond that, else always use three bytes where the first byte is TOKEN_ORDINAL
    
    Throws:
    
    IOException
  - readOrdinal
```
public static short readOrdinal(DataInput in)
                         throws IOException
```
    Reads ordinal as written by writeOrdinal(java.io.DataOutput, short, boolean) from given DataInput.
    
    Throws:
    
    IOException
  - readVersion
```
public static Version readVersion(DataInput in,
                  boolean returnNullForCurrent)
                           throws UnsupportedGFXDVersionException,
                                  IOException
```
    Return the Version reading from given DataInput as serialized by writeOrdinal(DataOutput, boolean). If the incoming ordinal is greater than or equal to current ordinal then this will return null or CURRENT indicating that version is same as that of CURRENT assuming that peer will support this JVM. This method is not meant to be used for client-server protocol since servers cannot support higher version clients, rather is only meant for P2P/JGroups messaging where a mixed version of servers can be running at the same time. Similarly cannot be used when recovering from disk since higher version data cannot be read.
    
    Parameters:
    in - the DataInput to read the version from
    returnNullForCurrent - if true then return null if incoming version >= CURRENT else return CURRENT
    
    Throws:
    
    UnsupportedGFXDVersionException
    
    IOException
  - fromOrdinalCheck
```
public static Version fromOrdinalCheck(short ordinal,
                       boolean returnNullForCurrent)
                                throws UnsupportedGFXDVersionException
```
    Return the Version represented by specified ordinal while not throwing exception if given ordinal is higher than any known ones.
    
    Throws:
    
    UnsupportedGFXDVersionException
  - readOrdinalFromInputStream
```
public static short readOrdinalFromInputStream(InputStream is)
                                        throws IOException
```
    Reads ordinal as written by writeOrdinal(java.io.DataOutput, short, boolean) from given InputStream. Returns -1 on end of stream.
    
    Throws:
    
    IOException
  - getGemFireVersion
```
public Version getGemFireVersion()
```
  - getMethodSuffix
```
public final String getMethodSuffix()
```
  - getProductName
```
public final String getProductName()
```
  - getName
```
public final String getName()
```
  - getMajorVersion
```
public final short getMajorVersion()
```
  - getMinorVersion
```
public final short getMinorVersion()
```
  - getRelease
```
public final short getRelease()
```
  - getPatch
```
public final short getPatch()
```
  - ordinal
```
public final short ordinal()
```
  - compatibleWith
```
public boolean compatibleWith(Version version)
```
    Returns whether this Version is compatible with the input Version
    
    Parameters:
    version - The Version to compare
    
    Returns:
    whether this Version is compatible with the input Version
  - compareTo
```
public final int compareTo(short other)
```
    Finds the Version instance corresponding to the given ordinal and returns the result of compareTo(Version)
    
    Parameters:
    other - the ordinal of the other Version object
    
    Returns:
    negative if this version is older, positive if this version is newer, 0 if this is the same version
  - compareTo
```
public final int compareTo(Version o)
```
    Specified by:
    
    compareTo in interface Comparable<Version>
  - toString
```
public String toString()
```
    Returns a string representation for this Version.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    the name of this operation.
  - toString
```
public static String toString(short ordinal)
```
  - toBytes
```
public byte[] toBytes()
```
  - fromBytes
```
public static Version fromBytes(byte[] bytes)
                         throws UnsupportedGFXDVersionException
```
    Throws:
    
    UnsupportedGFXDVersionException
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    
    equals in class Object
  - equals
```
public boolean equals(Version other)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class Version

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

Version_REMOTE_VERSION_NOT_SUPPORTED

NUM_OF_VERSIONS

TOKEN

GFE_56

GFE_57

GFE_58

GFE_603

GFE_61

GFE_65

GFE_651

GFE_6516

GFE_66

GFE_662

GFE_6622

GFE_70

GFE_701

SQLF_1099

GFE_7099

SQLF_11

GFE_71

GFE_75

GFXD_10

GFXD_101

GFXD_1011

GFXD_13

GFXD_1302

GFXD_14

GFXD_20

CURRENT

CURRENT_ORDINAL

NOT_SUPPORTED_ORDINAL

TEST_VERSION

Method Detail

fromOrdinal

fromOrdinalOrCurrent

writeOrdinal

writeOrdinal

uncompressedSize

compressedSize

writeOrdinal

readOrdinal

readVersion

fromOrdinalCheck

readOrdinalFromInputStream

getGemFireVersion

getMethodSuffix

getProductName

getName

getMajorVersion

getMinorVersion

getRelease

getPatch

ordinal

compatibleWith

compareTo

compareTo

toString

toString

toBytes

fromBytes

equals

equals

hashCode