Use internal keyword for functions in the internal package

cketti · cketti · commit 8eeb581131e4 · 2023-01-24T16:49:17.000+01:00
diff --git a/src/commonImplementation/kotlin/CodePoints.kt b/src/commonImplementation/kotlin/CodePoints.kt
@@ -13,23 +13,23 @@ import de.cketti.codepoints.internal.toChars as commonToChars
 import de.cketti.codepoints.internal.toCodePoint as commonToCodePoint
 
 actual object CodePoints {
-    actual inline fun isValidCodePoint(codePoint: Int): Boolean {
+    actual fun isValidCodePoint(codePoint: Int): Boolean {
         return commonIsValidCodePoint(codePoint)
     }
 
-    actual inline fun isBmpCodePoint(codePoint: Int): Boolean {
+    actual fun isBmpCodePoint(codePoint: Int): Boolean {
         return commonIsBmpCodePoint(codePoint)
     }
     
-    actual inline fun isSupplementaryCodePoint(codePoint: Int): Boolean {
+    actual fun isSupplementaryCodePoint(codePoint: Int): Boolean {
         return commonIsSupplementaryCodePoint(codePoint)
     }
 
-    actual inline fun charCount(codePoint: Int): Int {
+    actual fun charCount(codePoint: Int): Int {
         return commonCharCount(codePoint)
     }
 
-    actual inline fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {
+    actual fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {
         return commonIsSurrogatePair(highSurrogate, lowSurrogate)
     }
 
@@ -41,15 +41,15 @@ actual object CodePoints {
         return commonLowSurrogate(codePoint)
     }
 
-    actual inline fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {
+    actual fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {
         return commonToCodePoint(highSurrogate, lowSurrogate)
     }
 
-    actual inline fun toChars(codePoint: Int): CharArray {
+    actual fun toChars(codePoint: Int): CharArray {
         return commonToChars(codePoint)
     }
 
-    actual inline fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {
+    actual fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {
         return commonToChars(codePoint, destination, offset)
     }
 }
diff --git a/src/commonImplementation/kotlin/StringExtensions.kt b/src/commonImplementation/kotlin/StringExtensions.kt
@@ -7,18 +7,18 @@ import de.cketti.codepoints.internal.codePointBefore as commonCodePointBefore
 import de.cketti.codepoints.internal.codePointCount as commonCodePointCount
 import de.cketti.codepoints.internal.offsetByCodePoints as commonOffsetByCodePoints
 
-actual inline fun String.codePointAt(index: Int): Int {
+actual fun String.codePointAt(index: Int): Int {
     return commonCodePointAt(this, index)
 }
 
-actual inline fun String.codePointBefore(index: Int): Int {
+actual fun String.codePointBefore(index: Int): Int {
     return commonCodePointBefore(this, index)
 }
 
-actual inline fun String.codePointCount(beginIndex: Int, endIndex: Int): Int {
+actual fun String.codePointCount(beginIndex: Int, endIndex: Int): Int {
     return commonCodePointCount(this, beginIndex, endIndex)
 }
 
-actual inline fun String.offsetByCodePoints(index: Int, codePointOffset: Int): Int {
+actual fun String.offsetByCodePoints(index: Int, codePointOffset: Int): Int {
     return commonOffsetByCodePoints(this, index, codePointOffset)
 }
diff --git a/src/commonImplementation/kotlin/internal/CommonCodePoints.kt b/src/commonImplementation/kotlin/internal/CommonCodePoints.kt
@@ -12,47 +12,47 @@ private const val SURROGATE_DECODE_OFFSET =
 private const val HIGH_SURROGATE_ENCODE_OFFSET =
     (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT ushr 10))
 
-fun isValidCodePoint(codePoint: Int): Boolean {
+internal fun isValidCodePoint(codePoint: Int): Boolean {
     return codePoint in 0..MAX_CODE_POINT
 }
 
-fun isBmpCodePoint(codePoint: Int): Boolean {
+internal fun isBmpCodePoint(codePoint: Int): Boolean {
     return codePoint ushr 16 == 0
 }
 
-fun isSupplementaryCodePoint(codePoint: Int): Boolean {
+internal fun isSupplementaryCodePoint(codePoint: Int): Boolean {
     return codePoint in MIN_SUPPLEMENTARY_CODE_POINT..MAX_CODE_POINT
 }
 
-fun charCount(codePoint: Int): Int {
+internal fun charCount(codePoint: Int): Int {
     return if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) 1 else 2
 }
 
-fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {
+internal fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {
     return highSurrogate.isHighSurrogate() && lowSurrogate.isLowSurrogate()
 }
 
-fun highSurrogate(codePoint: Int): Char {
+internal fun highSurrogate(codePoint: Int): Char {
     return ((codePoint ushr 10) + HIGH_SURROGATE_ENCODE_OFFSET).toChar() 
 }
 
-fun lowSurrogate(codePoint: Int): Char {
+internal fun lowSurrogate(codePoint: Int): Char {
     return ((codePoint and 0x3FF) + MIN_LOW_SURROGATE).toChar()
 }
 
-fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {
+internal fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {
     return (highSurrogate.code shl 10) + lowSurrogate.code + SURROGATE_DECODE_OFFSET
 }
 
-fun toChars(codePoint: Int): CharArray {
+internal fun toChars(codePoint: Int): CharArray {
     return if (isBmpCodePoint(codePoint)) {
         charArrayOf(codePoint.toChar())
     } else {
         charArrayOf(highSurrogate(codePoint), lowSurrogate(codePoint))
     }
 }
 
-fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {
+internal fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {
     if (isBmpCodePoint(codePoint)) {
         destination.setSafe(offset, codePoint.toChar())
         return 1
diff --git a/src/commonImplementation/kotlin/internal/CommonStringBuilderFunctions.kt b/src/commonImplementation/kotlin/internal/CommonStringBuilderFunctions.kt
@@ -2,7 +2,7 @@ package de.cketti.codepoints.internal
 
 import de.cketti.codepoints.CodePoints
 
-fun appendCodePoint(builder: StringBuilder, codePoint: Int) {
+internal fun appendCodePoint(builder: StringBuilder, codePoint: Int) {
     if (CodePoints.isBmpCodePoint(codePoint)) {
         builder.append(codePoint.toChar())
     } else {
diff --git a/src/commonImplementation/kotlin/internal/CommonStringFunctions.kt b/src/commonImplementation/kotlin/internal/CommonStringFunctions.kt
@@ -1,6 +1,6 @@
 package de.cketti.codepoints.internal
 
-fun codePointAt(text: String, index: Int): Int {
+internal fun codePointAt(text: String, index: Int): Int {
     if (index !in text.indices) throw IndexOutOfBoundsException()
 
     val firstChar = text[index]
@@ -14,7 +14,7 @@ fun codePointAt(text: String, index: Int): Int {
     return firstChar.code
 }
 
-fun codePointBefore(text: String, index: Int): Int {
+internal fun codePointBefore(text: String, index: Int): Int {
     val startIndex = index - 1
     if (startIndex !in text.indices) throw IndexOutOfBoundsException()
 
@@ -29,7 +29,7 @@ fun codePointBefore(text: String, index: Int): Int {
     return firstChar.code
 }
 
-fun codePointCount(text: String, beginIndex: Int, endIndex: Int): Int {
+internal fun codePointCount(text: String, beginIndex: Int, endIndex: Int): Int {
     if (beginIndex < 0 || endIndex > text.length || beginIndex > endIndex) throw IndexOutOfBoundsException()
     
     var index = beginIndex
@@ -50,7 +50,7 @@ fun codePointCount(text: String, beginIndex: Int, endIndex: Int): Int {
     return count
 }
 
-fun offsetByCodePoints(text: String, index: Int, codePointOffset: Int): Int {
+internal fun offsetByCodePoints(text: String, index: Int, codePointOffset: Int): Int {
     if (index !in 0..text.length) throw IndexOutOfBoundsException()
     if (codePointOffset == 0) return index
 

Original file line number	Diff line number	Diff line change
`@@ -13,23 +13,23 @@ import de.cketti.codepoints.internal.toChars as commonToChars`
`13`	`13`	`import de.cketti.codepoints.internal.toCodePoint as commonToCodePoint`
`14`	`14`
`15`	`15`	`actual object CodePoints {`
`16`		`- actual inline fun isValidCodePoint(codePoint: Int): Boolean {`
	`16`	`+ actual fun isValidCodePoint(codePoint: Int): Boolean {`
`17`	`17`	`return commonIsValidCodePoint(codePoint)`
`18`	`18`	`}`
`19`	`19`
`20`		`- actual inline fun isBmpCodePoint(codePoint: Int): Boolean {`
	`20`	`+ actual fun isBmpCodePoint(codePoint: Int): Boolean {`
`21`	`21`	`return commonIsBmpCodePoint(codePoint)`
`22`	`22`	`}`
`23`	`23`
`24`		`- actual inline fun isSupplementaryCodePoint(codePoint: Int): Boolean {`
	`24`	`+ actual fun isSupplementaryCodePoint(codePoint: Int): Boolean {`
`25`	`25`	`return commonIsSupplementaryCodePoint(codePoint)`
`26`	`26`	`}`
`27`	`27`
`28`		`- actual inline fun charCount(codePoint: Int): Int {`
	`28`	`+ actual fun charCount(codePoint: Int): Int {`
`29`	`29`	`return commonCharCount(codePoint)`
`30`	`30`	`}`
`31`	`31`
`32`		`- actual inline fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {`
	`32`	`+ actual fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {`
`33`	`33`	`return commonIsSurrogatePair(highSurrogate, lowSurrogate)`
`34`	`34`	`}`
`35`	`35`
`@@ -41,15 +41,15 @@ actual object CodePoints {`
`41`	`41`	`return commonLowSurrogate(codePoint)`
`42`	`42`	`}`
`43`	`43`
`44`		`- actual inline fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {`
	`44`	`+ actual fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {`
`45`	`45`	`return commonToCodePoint(highSurrogate, lowSurrogate)`
`46`	`46`	`}`
`47`	`47`
`48`		`- actual inline fun toChars(codePoint: Int): CharArray {`
	`48`	`+ actual fun toChars(codePoint: Int): CharArray {`
`49`	`49`	`return commonToChars(codePoint)`
`50`	`50`	`}`
`51`	`51`
`52`		`- actual inline fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {`
	`52`	`+ actual fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {`
`53`	`53`	`return commonToChars(codePoint, destination, offset)`
`54`	`54`	`}`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,18 +7,18 @@ import de.cketti.codepoints.internal.codePointBefore as commonCodePointBefore`
`7`	`7`	`import de.cketti.codepoints.internal.codePointCount as commonCodePointCount`
`8`	`8`	`import de.cketti.codepoints.internal.offsetByCodePoints as commonOffsetByCodePoints`
`9`	`9`
`10`		`-actual inline fun String.codePointAt(index: Int): Int {`
	`10`	`+actual fun String.codePointAt(index: Int): Int {`
`11`	`11`	`return commonCodePointAt(this, index)`
`12`	`12`	`}`
`13`	`13`
`14`		`-actual inline fun String.codePointBefore(index: Int): Int {`
	`14`	`+actual fun String.codePointBefore(index: Int): Int {`
`15`	`15`	`return commonCodePointBefore(this, index)`
`16`	`16`	`}`
`17`	`17`
`18`		`-actual inline fun String.codePointCount(beginIndex: Int, endIndex: Int): Int {`
	`18`	`+actual fun String.codePointCount(beginIndex: Int, endIndex: Int): Int {`
`19`	`19`	`return commonCodePointCount(this, beginIndex, endIndex)`
`20`	`20`	`}`
`21`	`21`
`22`		`-actual inline fun String.offsetByCodePoints(index: Int, codePointOffset: Int): Int {`
	`22`	`+actual fun String.offsetByCodePoints(index: Int, codePointOffset: Int): Int {`
`23`	`23`	`return commonOffsetByCodePoints(this, index, codePointOffset)`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,47 +12,47 @@ private const val SURROGATE_DECODE_OFFSET =`
`12`	`12`	`private const val HIGH_SURROGATE_ENCODE_OFFSET =`
`13`	`13`	`(MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT ushr 10))`
`14`	`14`
`15`		`-fun isValidCodePoint(codePoint: Int): Boolean {`
	`15`	`+internal fun isValidCodePoint(codePoint: Int): Boolean {`
`16`	`16`	`return codePoint in 0..MAX_CODE_POINT`
`17`	`17`	`}`
`18`	`18`
`19`		`-fun isBmpCodePoint(codePoint: Int): Boolean {`
	`19`	`+internal fun isBmpCodePoint(codePoint: Int): Boolean {`
`20`	`20`	`return codePoint ushr 16 == 0`
`21`	`21`	`}`
`22`	`22`
`23`		`-fun isSupplementaryCodePoint(codePoint: Int): Boolean {`
	`23`	`+internal fun isSupplementaryCodePoint(codePoint: Int): Boolean {`
`24`	`24`	`return codePoint in MIN_SUPPLEMENTARY_CODE_POINT..MAX_CODE_POINT`
`25`	`25`	`}`
`26`	`26`
`27`		`-fun charCount(codePoint: Int): Int {`
	`27`	`+internal fun charCount(codePoint: Int): Int {`
`28`	`28`	`return if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) 1 else 2`
`29`	`29`	`}`
`30`	`30`
`31`		`-fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {`
	`31`	`+internal fun isSurrogatePair(highSurrogate: Char, lowSurrogate: Char): Boolean {`
`32`	`32`	`return highSurrogate.isHighSurrogate() && lowSurrogate.isLowSurrogate()`
`33`	`33`	`}`
`34`	`34`
`35`		`-fun highSurrogate(codePoint: Int): Char {`
	`35`	`+internal fun highSurrogate(codePoint: Int): Char {`
`36`	`36`	`return ((codePoint ushr 10) + HIGH_SURROGATE_ENCODE_OFFSET).toChar()`
`37`	`37`	`}`
`38`	`38`
`39`		`-fun lowSurrogate(codePoint: Int): Char {`
	`39`	`+internal fun lowSurrogate(codePoint: Int): Char {`
`40`	`40`	`return ((codePoint and 0x3FF) + MIN_LOW_SURROGATE).toChar()`
`41`	`41`	`}`
`42`	`42`
`43`		`-fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {`
	`43`	`+internal fun toCodePoint(highSurrogate: Char, lowSurrogate: Char): Int {`
`44`	`44`	`return (highSurrogate.code shl 10) + lowSurrogate.code + SURROGATE_DECODE_OFFSET`
`45`	`45`	`}`
`46`	`46`
`47`		`-fun toChars(codePoint: Int): CharArray {`
	`47`	`+internal fun toChars(codePoint: Int): CharArray {`
`48`	`48`	`return if (isBmpCodePoint(codePoint)) {`
`49`	`49`	`charArrayOf(codePoint.toChar())`
`50`	`50`	`} else {`
`51`	`51`	`charArrayOf(highSurrogate(codePoint), lowSurrogate(codePoint))`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`-fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {`
	`55`	`+internal fun toChars(codePoint: Int, destination: CharArray, offset: Int): Int {`
`56`	`56`	`if (isBmpCodePoint(codePoint)) {`
`57`	`57`	`destination.setSafe(offset, codePoint.toChar())`
`58`	`58`	`return 1`