Binary strings: Difference between revisions

=={{header|Kotlin}}==

Strings in Kotlin are sequences of 16-bit unicode characters and have a lot of functions built-in, including all those required by this task.

To do something different and consistent with the task, I've therefore implemented a simple ByteString class as a sequence of 8-bit signed bytes (Kotlin doesn't yet have an unsigned byte type) using the ISO 8859-1 encoding which, of course, represents the first 256 unicode characters. It's not possible to create user-defined literals in Kotlin and so ByteStrings need to be converted to 'ordinary' Strings to display them as such.

The implementation is not intended to be particularly efficient as I've sometimes delegated to the corresponding String class functions in the interests of both simplicity and brevity. Moreover, when Java 9's 'compact strings' feature is implemented, it won't even save memory as Strings which don't contain characters with code-points above 255 are apparently going to be flagged and stored internally as arrays of single bytes by the JVM, not arrays of 2 byte characters as at present.

<lang scala>// version 1.1.2

class ByteString(private val bytes: ByteArray) : Comparable<ByteString> {

val length get() = bytes.size

fun isEmpty() = bytes.size == 0

operator fun plus(other: ByteString): ByteString = ByteString(bytes + other.bytes)

operator fun plus(byte: Byte) = ByteString(bytes + byte)

operator fun get(index: Int): Byte {

require (index in 0 until length)

return bytes[index]

}

fun toByteArray() = bytes

fun copy() = ByteString(bytes.copyOf())

override fun compareTo(other: ByteString) = this.toString().compareTo(other.toString())

override fun equals(other: Any?): Boolean {

if (other == null || other !is ByteString) return false

return compareTo(other) == 0

}

override fun hashCode() = this.toString().hashCode()

fun substring(startIndex: Int) = ByteString(bytes.sliceArray(startIndex until length))

fun substring(startIndex: Int, endIndex: Int) =

ByteString(bytes.sliceArray(startIndex until endIndex))

fun replace(oldByte: Byte, newByte: Byte): ByteString {

val ba = ByteArray(length) { if (bytes[it] == oldByte) newByte else bytes[it] }

return ByteString(ba)

}

fun replace(oldValue: ByteString, newValue: ByteString) =

this.toString().replace(oldValue.toString(), newValue.toString()).toByteString()

override fun toString(): String {

val chars = CharArray(length)

for (i in 0 until length) {

chars[i] = when (bytes[i]) {

in 0..127 -> bytes[i].toChar()

else -> (256 + bytes[i]).toChar()

}

}

return chars.joinToString("")

}

}

fun String.toByteString(): ByteString {

val bytes = ByteArray(this.length)

for (i in 0 until this.length) {

bytes[i] = when (this[i].toInt()) {

in 0..127 -> this[i].toByte()

in 128..255 -> (this[i] - 256).toByte()

else -> '?'.toByte() // say

}

}

return ByteString(bytes)

}

/* property to be used as an abbreviation for String.toByteString() */

val String.bs get() = this.toByteString()

fun main(args: Array<String>) {

val ba = byteArrayOf(65, 66, 67)

val ba2 = byteArrayOf(68, 69, 70)

val bs = ByteString(ba)

val bs2 = ByteString(ba2)

val bs3 = bs + bs2

val bs4 = "GHI£€".toByteString()

println("The length of $bs is ${bs.length}")

println("$bs + $bs2 = $bs3")

println("$bs + D = ${bs + 68}")

println("$bs == ABC is ${bs == bs.copy()}")

println("$bs != ABC is ${bs != bs.copy()}")

println("$bs >= $bs2 is ${bs > bs2}")

println("$bs <= $bs2 is ${bs < bs2}")

println("$bs is ${if (bs.isEmpty()) "empty" else "not empty"}")

println("ABC[1] = ${bs[1].toChar()}")

println("ABC as a byte array is ${bs.toByteArray().contentToString()}")

println("ABCDEF(1..5) = ${bs3.substring(1)}")

println("ABCDEF(2..4) = ${bs3.substring(2,5)}")

println("ABCDEF with C replaced by G is ${bs3.replace(67, 71)}")

println("ABCDEF with CD replaced by GH is ${bs3.replace("CD".bs, "GH".bs)}")

println("GHI£€ as a ByteString is $bs4")

}</lang>

{{out}}

<pre>

The length of ABC is 3

ABC + DEF = ABCDEF

ABC + D = ABCD

ABC == ABC is true

ABC != ABC is false

ABC >= DEF is false

ABC <= DEF is true

ABC is not empty

ABC[1] = B

ABC as a byte array is [65, 66, 67]

ABCDEF(1..5) = BCDEF

ABCDEF(2..4) = CDE

ABCDEF with C replaced by G is ABGDEF

ABCDEF with CD replaced by GH is ABGHEF

GHI£€ as a ByteString is GHI£?

</pre>