Inline implementations in actuals

With the dedicated platform testing gone, this indirection is no longer needed. The common tests still validate behavioral conformity across all platforms.

Author: JakeWharton

src/commonImplementation/kotlin/CodePoints.kt

@@ -1,55 +1,77 @@
-@file:Suppress("NOTHING_TO_INLINE")
-
 package de.cketti.codepoints
 
-import de.cketti.codepoints.internal.charCount as commonCharCount
-import de.cketti.codepoints.internal.highSurrogate as commonHighSurrogate
-import de.cketti.codepoints.internal.isBmpCodePoint as commonIsBmpCodePoint
-import de.cketti.codepoints.internal.isSupplementaryCodePoint as commonIsSupplementaryCodePoint
-import de.cketti.codepoints.internal.isSurrogatePair as commonIsSurrogatePair
-import de.cketti.codepoints.internal.isValidCodePoint as commonIsValidCodePoint
-import de.cketti.codepoints.internal.lowSurrogate as commonLowSurrogate
-import de.cketti.codepoints.internal.toChars as commonToChars
-import de.cketti.codepoints.internal.toCodePoint as commonToCodePoint
-
 actual object CodePoints {
+    private const val MIN_SUPPLEMENTARY_CODE_POINT = 0x10000
+    private const val MAX_CODE_POINT = 0x10FFFF
+
+    private const val MIN_HIGH_SURROGATE = 0xD800
+    private const val MIN_LOW_SURROGATE = 0xDC00
+
+    private const val SURROGATE_DECODE_OFFSET =
+            MIN_SUPPLEMENTARY_CODE_POINT - (MIN_HIGH_SURROGATE shl 10) - MIN_LOW_SURROGATE
+
+    private const val HIGH_SURROGATE_ENCODE_OFFSET =
+            (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT ushr 10))
+
     actual fun isValidCodePoint(codePoint: Int): Boolean {
-        return commonIsValidCodePoint(codePoint)
+        return codePoint in 0..MAX_CODE_POINT
     }
 
     actual fun isBmpCodePoint(codePoint: Int): Boolean {
-        return commonIsBmpCodePoint(codePoint)
+        return codePoint ushr 16 == 0
     }
 
     actual fun isSupplementaryCodePoint(codePoint: Int): Boolean {
-        return commonIsSupplementaryCodePoint(codePoint)
+        return codePoint in MIN_SUPPLEMENTARY_CODE_POINT..MAX_CODE_POINT
     }
 
     actual fun charCount(codePoint: Int): Int {
-        return commonCharCount(codePoint)
+        return if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) 1 else 2
     }
 
     actual fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {
-        return commonIsSurrogatePair(highSurrogate, lowSurrogate)
+        return highSurrogate.isHighSurrogate() && lowSurrogate.isLowSurrogate()
     }
 
     actual fun highSurrogate(codePoint: Int): Char {
-        return commonHighSurrogate(codePoint)
+        return ((codePoint ushr 10) + HIGH_SURROGATE_ENCODE_OFFSET).toChar()
     }
 
     actual fun lowSurrogate(codePoint: Int): Char {
-        return commonLowSurrogate(codePoint)
+        return ((codePoint and 0x3FF) + MIN_LOW_SURROGATE).toChar()
     }
 
     actual fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {
-        return commonToCodePoint(highSurrogate, lowSurrogate)
+        return (highSurrogate.code shl 10) + lowSurrogate.code + SURROGATE_DECODE_OFFSET
     }
 
     actual fun toChars(codePoint: Int): CharArray {
-        return commonToChars(codePoint)
+        return if (isBmpCodePoint(codePoint)) {
+            charArrayOf(codePoint.toChar())
+        } else {
+            charArrayOf(highSurrogate(codePoint), lowSurrogate(codePoint))
+        }
     }
 
     actual fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {
-        return commonToChars(codePoint, destination, offset)
+        if (isBmpCodePoint(codePoint)) {
+            destination.setSafe(offset, codePoint.toChar())
+            return 1
+        } else {
+            // When writing the low surrogate succeeds but writing the high surrogate fails (offset = -1), the
+            // destination will be modified even though the method throws. This feels wrong, but matches the behavior
+            // of the Java stdlib implementation.
+            destination.setSafe(offset + 1, lowSurrogate(codePoint))
+            destination.setSafe(offset, highSurrogate(codePoint))
+            return 2
+        }
+    }
+
+    private fun CharArray.setSafe(index: Int, value: Char) {
+        if (index !in this.indices) {
+            throw IndexOutOfBoundsException("Size: $size, offset: $index")
+        }
+
+        this[index] = value
     }
 }

src/commonImplementation/kotlin/StringBuilderExtensions.kt

@@ -1,8 +1,15 @@
 package de.cketti.codepoints
 
+import de.cketti.codepoints.CodePoints.highSurrogate
+import de.cketti.codepoints.CodePoints.isBmpCodePoint
+import de.cketti.codepoints.CodePoints.lowSurrogate
 import kotlin.text.StringBuilder
-import de.cketti.codepoints.internal.appendCodePoint as commonAppendCodePoint
 
 actual fun StringBuilder.appendCodePoint(codePoint: Int): StringBuilder = apply {
-    commonAppendCodePoint(this, codePoint)
+    if (isBmpCodePoint(codePoint)) {
+        append(codePoint.toChar())
+    } else {
+        append(highSurrogate(codePoint))
+        append(lowSurrogate(codePoint))
+    }
 }

src/commonImplementation/kotlin/StringExtensions.kt

@@ -1,24 +1,90 @@
-@file:Suppress("NOTHING_TO_INLINE")
-
 package de.cketti.codepoints
 
-import de.cketti.codepoints.internal.codePointAt as commonCodePointAt
-import de.cketti.codepoints.internal.codePointBefore as commonCodePointBefore
-import de.cketti.codepoints.internal.codePointCount as commonCodePointCount
-import de.cketti.codepoints.internal.offsetByCodePoints as commonOffsetByCodePoints
+import de.cketti.codepoints.CodePoints.toCodePoint
 
 actual fun String.codePointAt(index: Int): Int {
-    return commonCodePointAt(this, index)
+    if (index !in indices) throw IndexOutOfBoundsException()
+
+    val firstChar = this[index]
+    if (firstChar.isHighSurrogate() && index + 1 < length) {
+        val nextChar = this[index + 1]
+        if (nextChar.isLowSurrogate()) {
+            return toCodePoint(firstChar, nextChar)
+        }
+    }
+
+    return firstChar.code
 }
 
 actual fun String.codePointBefore(index: Int): Int {
-    return commonCodePointBefore(this, index)
+    val startIndex = index - 1
+    if (startIndex !in indices) throw IndexOutOfBoundsException()
+
+    val firstChar = this[startIndex]
+    if (firstChar.isLowSurrogate() && startIndex - 1 >= 0) {
+        val previousChar = this[startIndex - 1]
+        if (previousChar.isHighSurrogate()) {
+            return toCodePoint(previousChar, firstChar)
+        }
+    }
+
+    return firstChar.code
 }
 
 actual fun String.codePointCount(beginIndex: Int, endIndex: Int): Int {
-    return commonCodePointCount(this, beginIndex, endIndex)
+    if (beginIndex < 0 || endIndex > length || beginIndex > endIndex) throw IndexOutOfBoundsException()
+
+    var index = beginIndex
+    var count = 0
+    do {
+        val firstChar = this[index]
+        index++
+        if (firstChar.isHighSurrogate() && index < endIndex) {
+            val nextChar = this[index]
+            if (nextChar.isLowSurrogate()) {
+                index++
+            }
+        }
+
+        count++
+    } while (index < endIndex)
+
+    return count
 }
 
 actual fun String.offsetByCodePoints(index: Int, codePointOffset: Int): Int {
-    return commonOffsetByCodePoints(this, index, codePointOffset)
+    if (index !in 0..length) throw IndexOutOfBoundsException()
+    if (codePointOffset == 0) return index
+
+    if (codePointOffset > 0) {
+        var currentIndex = index
+        repeat(codePointOffset) {
+            if (currentIndex > lastIndex) throw IndexOutOfBoundsException()
+            val firstChar = this[currentIndex]
+            currentIndex++
+            if (firstChar.isHighSurrogate() && currentIndex <= lastIndex) {
+                val nextChar = this[currentIndex]
+                if (nextChar.isLowSurrogate()) {
+                    currentIndex++
+                }
+            }
+        }
+
+        return currentIndex
+    } else {
+        var currentIndex = index - 1
+        repeat(-codePointOffset) {
+            if (currentIndex < 0) throw IndexOutOfBoundsException()
+            val firstChar = this[currentIndex]
+            currentIndex--
+            if (firstChar.isLowSurrogate() && currentIndex >= 0) {
+                val previousChar = this[currentIndex]
+                if (previousChar.isHighSurrogate()) {
+                    currentIndex--
+                }
+            }
+        }
+
+        return currentIndex + 1
+    }
 }