interface Bytes48 : Bytes
(source)
A Bytes value that is guaranteed to contain exactly 48 bytes.
static val SIZE: Int
The number of bytes in this value - i.e. 48 |
|
static val ZERO: Bytes48
A |
static val EMPTY: Bytes
The empty value (with 0 bytes). |
open fun and(other: Bytes48): Bytes48
Return a bit-wise AND of these bytes and the supplied bytes. |
|
abstract fun copy(): Bytes48 |
|
open static fun fromHexString(str: CharSequence): Bytes48
Parse a hexadecimal string into a Bytes48. This method is strict in that |
|
open static fun fromHexStringLenient(str: CharSequence): Bytes48
Parse a hexadecimal string into a Bytes48. This method is lenient in that |
|
open static fun fromHexStringStrict(str: CharSequence): Bytes48
Parse a hexadecimal string into a Bytes48. This method is extra strict in that |
|
open static fun leftPad(value: Bytes): Bytes48
Left pad a Bytes value with zero bytes to create a Bytes48. |
|
abstract fun mutableCopy(): MutableBytes48 |
|
open fun not(): Bytes48 |
|
open fun or(other: Bytes48): Bytes48
Return a bit-wise OR of these bytes and the supplied bytes. |
|
open static fun random(): Bytes48 open static fun random(generator: Random): Bytes48
Generate random bytes. |
|
open static fun rightPad(value: Bytes): Bytes48
Right pad a Bytes value with zero bytes to create a Bytes48. |
|
open fun shiftLeft(distance: Int): Bytes48 |
|
open fun shiftRight(distance: Int): Bytes48 |
|
open fun size(): Int |
|
open static fun wrap(bytes: ByteArray): Bytes48
Wrap the provided byte array, which must be of length 48, as a Bytes48. Note that value is not copied, only wrapped, and thus any future update to open static fun wrap(bytes: ByteArray, offset: Int): Bytes48
Wrap a slice/sub-part of the provided array as a Bytes48. Note that value is not copied, only wrapped, and thus any future update to open static fun wrap(value: Bytes): Bytes48
Wrap a the provided value, which must be of size 48, as a Bytes48. Note that value is not copied, only wrapped, and thus any future update to open static fun wrap(value: Bytes, offset: Int): Bytes48
Wrap a slice/sub-part of the provided value as a Bytes48. Note that value is not copied, only wrapped, and thus any future update to |
|
open fun xor(other: Bytes48): Bytes48
Return a bit-wise XOR of these bytes and the supplied 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 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 |
|
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 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 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 fun reverse(): Bytes
Computes the reverse array of bytes of the current bytes. |
|
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 <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). |
|
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 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. |
open class DelegatingBytes48 : AbstractBytes, Bytes48
A class that holds and delegates all operations to its inner bytes field. This class may be used to create more types that represent 48 bytes, but need a different name for business logic. |
|
interface MutableBytes48 : MutableBytes, Bytes48
A mutable Bytes48, that is a mutable Bytes value of exactly 48 bytes. |