tuweni / org.apache.tuweni.bytes / Bytes

Bytes

interface 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.

Properties

EMPTY

static val EMPTY: Bytes

The empty value (with 0 bytes).

Functions

and

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.

appendHexTo

open fun <T : Appendable> appendHexTo(appendable: T): T

Append this value as a sequence of hexadecimal characters.

appendTo

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.

bitLength

open fun bitLength(): Int

commonPrefix

open fun commonPrefix(other: Bytes): Bytes

Return a slice over the common prefix between this set of bytes and another.

commonPrefixLength

open fun commonPrefixLength(other: Bytes): Int

Return the number of bytes in common between this set of bytes and another.

concatenate

open static fun concatenate(vararg values: Bytes): Bytes

Create a value containing the concatenation of the values provided.

copy

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.

copyTo

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 copyTo(destination.mutableSlice(destinationOffset, this.size())).

fromBase64String

open static fun fromBase64String(str: CharSequence): Bytes

Parse a base 64 string into a Bytes value.

fromHexString

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 str have an even length.

fromHexStringLenient

open static fun fromHexStringLenient(str: CharSequence): Bytes

Parse a hexadecimal string into a Bytes value.

This method is lenient in that str may of an odd length, in which case it will behave exactly as if it had an additional 0 in front.

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 str to have an odd length, in which case it will behave exactly as if it had an additional 0 in front.

get

abstract fun get(i: Int): Byte

Retrieve a byte in this value.

getInt

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.

getLong

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.

hasLeadingZero

open fun hasLeadingZero(): Boolean

Whether the bytes start with a zero bit value.

hasLeadingZeroByte

open fun hasLeadingZeroByte(): Boolean

Whether the bytes start with a zero byte value.

isEmpty

open fun isEmpty(): Boolean

Whether this value contains no bytes.

isZero

open fun isZero(): Boolean

Whether this value has only zero bytes.

minimalBytes

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.

mutableCopy

abstract fun mutableCopy(): MutableBytes

Return a new mutable value initialized with the content of this value.

not

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.

numberOfLeadingZeroBytes

open fun numberOfLeadingZeroBytes(): Int

numberOfLeadingZeros

open fun numberOfLeadingZeros(): Int

numberOfTrailingZeroBytes

open fun numberOfTrailingZeroBytes(): Int

of

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.

ofUnsignedInt

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.

ofUnsignedLong

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.

ofUnsignedShort

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.

or

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.

random

open static fun random(size: Int): Bytes
open static fun random(size: Int, generator: Random): Bytes

Generate random bytes.

reverse

open fun reverse(): Bytes

Computes the reverse array of bytes of the current bytes.

shiftLeft

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.

shiftRight

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).

size

abstract fun size(): Int

slice

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 #copy on the returned slice if that is not what you want.

toArray

open fun toArray(): ByteArray

Extract the bytes of this value into a byte array.

toArrayUnsafe

open fun toArrayUnsafe(): ByteArray

Get the bytes represented by this value as byte array.

Contrarily to #toArray(), this may avoid allocating a new array and directly return the backing array of this value if said value is array backed and doing so is possible. As such, modifications to the returned array may or may not impact this value. As such, this method should be used with care and hence the "unsafe" moniker.

toBase64String

open fun toBase64String(): String

toBigInteger

open fun toBigInteger(): BigInteger
open fun toBigInteger(order: ByteOrder): BigInteger

The BigInteger corresponding to interpreting these bytes as a two's-complement signed integer.

toHexString

open fun toHexString(): String

toInt

open fun toInt(): Int
open fun toInt(order: ByteOrder): Int

The value corresponding to interpreting these bytes as an integer.

toLong

open fun toLong(): Long
open fun toLong(order: ByteOrder): Long

The value corresponding to interpreting these bytes as a long.

toShortHexString

open fun toShortHexString(): String

toUnsignedBigInteger

open fun toUnsignedBigInteger(): BigInteger
open fun toUnsignedBigInteger(order: ByteOrder): BigInteger

The BigInteger corresponding to interpreting these bytes as an unsigned integer.

trimLeadingZeros

open fun trimLeadingZeros(): Bytes

Return a slice of representing the same value but without any leading zero bytes.

update

open fun update(digest: MessageDigest): Unit

Update the provided message digest with the bytes of this value.

wrap

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 value will be reflected in the returned value.

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 value within the slice will be reflected in the returned value.

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 #concatenate(Bytes...).

wrapBuffer

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.

wrapByteBuf

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.

wrapByteBuffer

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.

xor

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.

Inheritors

AbstractBytes

abstract class AbstractBytes : Bytes

An abstract Bytes value that provides implementations of #equals(Object), #hashCode() and #toString().

Bytes32

interface Bytes32 : Bytes

A Bytes value that is guaranteed to contain exactly 32 bytes.

Bytes48

interface Bytes48 : Bytes

A Bytes value that is guaranteed to contain exactly 48 bytes.

MutableBytes

interface MutableBytes : Bytes

A mutable Bytes value.