interface Bytes : Comparable<Bytes>
(source)
A value made of bytes.
This interface makes no thread-safety guarantee, and a Bytes value is generally not thread safe. However, specific implementations may be thread-safe. For instance, the value returned by #copy
is guaranteed to be thread-safe as it is immutable.
static val EMPTY: Bytes
The empty value (with 0 bytes). |
open fun and(other: Bytes): Bytes
Return a bit-wise AND of these bytes and the supplied bytes. If this value and the supplied value are different lengths, then the shorter will be zero-padded to the left. open fun <T : MutableBytes> and(other: Bytes, result: T): T
Calculate a bit-wise AND of these bytes and the supplied bytes. If this value or the supplied value are shorter in length than the output vector, then they will be zero-padded to the left. Likewise, if either this value or the supplied valid is longer in length than the output vector, then they will be truncated to the left. |
|
open fun <T : Appendable> appendHexTo(appendable: T): T
Append this value as a sequence of hexadecimal characters. |
|
open fun appendTo(byteBuffer: ByteBuffer): Unit
Append the bytes of this value to the ByteBuffer. open fun appendTo(buffer: Buffer): Unit
Append the bytes of this value to the provided Vert.x Buffer. Note that since a Vert.x Buffer will grow as necessary, this method never fails. |
|
open fun bitLength(): Int |
|
open fun commonPrefix(other: Bytes): Bytes
Return a slice over the common prefix between this set of bytes and another. |
|
open fun commonPrefixLength(other: Bytes): Int
Return the number of bytes in common between this set of bytes and another. |
|
open fun compareTo(other: Bytes): Int |
|
open static fun concatenate(vararg values: Bytes): Bytes
Create a value containing the concatenation of the values provided. |
|
abstract fun copy(): Bytes
Return a value equivalent to this one but guaranteed to 1) be deeply immutable (i.e. the underlying value will be immutable) and 2) to not retain more bytes than exposed by the value. |
|
open fun copyTo(destination: MutableBytes): Unit
Copy the bytes of this value to the provided mutable one, which must have the same size. open fun copyTo(destination: MutableBytes, destinationOffset: Int): Unit
Copy the bytes of this value to the provided mutable one from a particular offset. This is a (potentially slightly more efficient) shortcut for |
|
open static fun fromBase64String(str: CharSequence): Bytes
Parse a base 64 string into a Bytes value. |
|
open static fun fromHexString(str: CharSequence): Bytes open static fun fromHexString(str: CharSequence, destinationSize: Int): Bytes
Parse a hexadecimal string into a Bytes value. This method requires that |
|
open static fun fromHexStringLenient(str: CharSequence): Bytes
Parse a hexadecimal string into a Bytes value. This method is lenient in that open static fun fromHexStringLenient(str: CharSequence, destinationSize: Int): Bytes
Parse a hexadecimal string into a Bytes value of the provided size. This method allows for |
|
abstract fun get(i: Int): Byte
Retrieve a byte in this value. |
|
open fun getInt(i: Int): Int open fun getInt(i: Int, order: ByteOrder): Int
Retrieve the 4 bytes starting at the provided index in this value as an integer. |
|
open fun getLong(i: Int): Long open fun getLong(i: Int, order: ByteOrder): Long
Retrieves the 8 bytes starting at the provided index in this value as a long. |
|
open fun hasLeadingZero(): Boolean
Whether the bytes start with a zero bit value. |
|
open fun hasLeadingZeroByte(): Boolean
Whether the bytes start with a zero byte value. |
|
open fun isEmpty(): Boolean
Whether this value contains no bytes. |
|
open fun isZero(): Boolean
Whether this value has only zero bytes. |
|
open static fun minimalBytes(value: Long): Bytes
Return the smallest bytes value whose bytes correspond to the provided long. That is, the returned value may be of size less than 8 if the provided long has leading zero bytes. |
|
abstract fun mutableCopy(): MutableBytes
Return a new mutable value initialized with the content of this value. |
|
open fun not(): Bytes
Return a bit-wise NOT of these bytes. open fun <T : MutableBytes> not(result: T): T
Calculate a bit-wise NOT of these bytes. If this value is shorter in length than the output vector, then it will be zero-padded to the left. Likewise, if this value is longer in length than the output vector, then it will be truncated to the left. |
|
open fun numberOfLeadingZeroBytes(): Int |
|
open fun numberOfLeadingZeros(): Int |
|
open fun numberOfTrailingZeroBytes(): Int |
|
open static fun of(vararg bytes: Byte): Bytes open static fun of(vararg bytes: Int): Bytes
Create a value that contains the specified bytes in their specified order. |
|
open static fun ofUnsignedInt(value: Long): Bytes open static fun ofUnsignedInt(value: Long, order: ByteOrder): Bytes
Return a 4-byte value corresponding to the provided value interpreted as an unsigned int. |
|
open static fun ofUnsignedLong(value: Long): Bytes open static fun ofUnsignedLong(value: Long, order: ByteOrder): Bytes
Return an 8-byte value corresponding to the provided value interpreted as an unsigned long. |
|
open static fun ofUnsignedShort(value: Int): Bytes open static fun ofUnsignedShort(value: Int, order: ByteOrder): Bytes
Return a 2-byte value corresponding to the provided value interpreted as an unsigned short. |
|
open fun or(other: Bytes): Bytes
Return a bit-wise OR of these bytes and the supplied bytes. If this value and the supplied value are different lengths, then the shorter will be zero-padded to the left. open fun <T : MutableBytes> or(other: Bytes, result: T): T
Calculate a bit-wise OR of these bytes and the supplied bytes. If this value or the supplied value are shorter in length than the output vector, then they will be zero-padded to the left. Likewise, if either this value or the supplied valid is longer in length than the output vector, then they will be truncated to the left. |
|
open static fun random(size: Int): Bytes open static fun random(size: Int, generator: Random): Bytes
Generate random bytes. |
|
open fun reverse(): Bytes
Computes the reverse array of bytes of the current bytes. |
|
open fun shiftLeft(distance: Int): Bytes
Shift all bits in this value to the left. open fun <T : MutableBytes> shiftLeft(distance: Int, result: T): T
Shift all bits in this value to the left. If this value is shorter in length than the output vector, then it will be zero-padded to the left. Likewise, if this value is longer in length than the output vector, then it will be truncated to the left. |
|
open fun shiftRight(distance: Int): Bytes
Shift all bits in this value to the right. open fun <T : MutableBytes> shiftRight(distance: Int, result: T): T
Shift all bits in this value to the right. If this value is shorter in length than the output vector, then it will be zero-padded to the left. Likewise, if this value is longer in length than the output vector, then it will be truncated to the left (after shifting). |
|
abstract fun size(): Int |
|
open fun slice(i: Int): Bytes abstract fun slice(i: Int, length: Int): Bytes
Create a new value representing (a view of) a slice of the bytes of this value. Please note that the resulting slice is only a view and as such maintains a link to the underlying full value. So holding a reference to the returned slice may hold more memory than the slide represents. Use |
|
open fun toArray(): ByteArray
Extract the bytes of this value into a byte array. |
|
open fun toArrayUnsafe(): ByteArray
Get the bytes represented by this value as byte array. Contrarily to |
|
open fun toBase64String(): String |
|
open fun toBigInteger(): BigInteger open fun toBigInteger(order: ByteOrder): BigInteger
The BigInteger corresponding to interpreting these bytes as a two's-complement signed integer. |
|
open fun toHexString(): String |
|
open fun toInt(): Int open fun toInt(order: ByteOrder): Int
The value corresponding to interpreting these bytes as an integer. |
|
open fun toLong(): Long open fun toLong(order: ByteOrder): Long
The value corresponding to interpreting these bytes as a long. |
|
open fun toShortHexString(): String |
|
open fun toUnprefixedHexString(): String |
|
open fun toUnsignedBigInteger(): BigInteger open fun toUnsignedBigInteger(order: ByteOrder): BigInteger
The BigInteger corresponding to interpreting these bytes as an unsigned integer. |
|
open fun trimLeadingZeros(): Bytes
Return a slice of representing the same value but without any leading zero bytes. |
|
open fun update(digest: MessageDigest): Unit
Update the provided message digest with the bytes of this value. |
|
open static fun wrap(value: ByteArray): Bytes
Wrap the provided byte array as a Bytes value. Note that value is not copied and thus any future update to open static fun wrap(value: ByteArray, offset: Int, length: Int): Bytes
Wrap a slice of a byte array as a Bytes value. Note that value is not copied and thus any future update to open static fun wrap(vararg values: Bytes): Bytes
Wrap a list of other values into a concatenated view. Note that the values are not copied and thus any future update to the values will be reflected in the returned value. If copying the inputs is desired, use |
|
open static fun wrapBuffer(buffer: Buffer): Bytes
Wrap a full Vert.x Buffer as a Bytes value. Note that any change to the content of the buffer may be reflected in the returned value. open static fun wrapBuffer(buffer: Buffer, offset: Int, size: Int): Bytes
Wrap a slice of a Vert.x Buffer as a Bytes value. Note that any change to the content of the buffer may be reflected in the returned value. |
|
open static fun wrapByteBuf(byteBuf: ByteBuf): Bytes
Wrap a full Netty ByteBuf as a Bytes value. Note that any change to the content of the byteBuf may be reflected in the returned value. open static fun wrapByteBuf(byteBuf: ByteBuf, offset: Int, size: Int): Bytes
Wrap a slice of a Netty ByteBuf as a Bytes value. Note that any change to the content of the buffer may be reflected in the returned value. |
|
open static fun wrapByteBuffer(byteBuffer: ByteBuffer): Bytes
Wrap a full Java NIO ByteBuffer as a Bytes value. Note that any change to the content of the byteBuf may be reflected in the returned value. open static fun wrapByteBuffer(byteBuffer: ByteBuffer, offset: Int, size: Int): Bytes
Wrap a slice of a Java NIO ByteBuf as a Bytes value. Note that any change to the content of the buffer may be reflected in the returned value. |
|
open fun xor(other: Bytes): Bytes
Return a bit-wise XOR of these bytes and the supplied bytes. If this value and the supplied value are different lengths, then the shorter will be zero-padded to the left. open fun <T : MutableBytes> xor(other: Bytes, result: T): T
Calculate a bit-wise XOR of these bytes and the supplied bytes. If this value or the supplied value are shorter in length than the output vector, then they will be zero-padded to the left. Likewise, if either this value or the supplied valid is longer in length than the output vector, then they will be truncated to the left. |
abstract class AbstractBytes : Bytes
An abstract Bytes value that provides implementations of |
|
interface Bytes32 : Bytes
A Bytes value that is guaranteed to contain exactly 32 bytes. |
|
interface Bytes48 : Bytes
A Bytes value that is guaranteed to contain exactly 48 bytes. |
|
open class DelegatingBytes : AbstractBytes, Bytes
A class that holds and delegates all operations to its inner bytes field. This class may be used to create more types that represent bytes, but need a different name for business logic. |
|
interface MutableBytes : Bytes
A mutable Bytes value. |