Rename eof to exhauested. Add description about performance penalty

e5l · e5l · commit 3e736f33279d · 2020-03-03T12:02:16.000+03:00
diff --git a/core/commonMain/src/kotlinx/io/Input.kt b/core/commonMain/src/kotlinx/io/Input.kt
@@ -209,9 +209,12 @@ public abstract class Input : Closeable {
 
     /**
      * Check if at least one byte is available to read.
+     *
+     * This method can use [fill] if no bytes are available in the cache. Please consider using [readAvailableTo] in
+     * performance-critical code.
      */
     @Suppress("NOTHING_TO_INLINE")
-    public inline fun eof(): Boolean = !prefetch(1)
+    public inline fun exhausted(): Boolean = !prefetch(1)
 
     /**
      * Checks that [size] bytes are fetched in [Input].
diff --git a/core/commonMain/src/kotlinx/io/text/TextInput.kt b/core/commonMain/src/kotlinx/io/text/TextInput.kt
@@ -25,7 +25,7 @@ public fun Input.readUtf8Lines(): List<String> {
     checkExhausted()
     val list = ArrayList<String>()
     use {
-        while (!eof()) {
+        while (!exhausted()) {
             list += readUtf8Line()
         }
     }
@@ -40,12 +40,12 @@ public fun Input.readUtf8Lines(): List<String> {
  */
 public inline fun Input.forEachUtf8Line(action: (String) -> Unit) {
     use {
-        while (!eof()) {
+        while (!exhausted()) {
             action(readUtf8Line())
         }
     }
 }
 
 private fun Input.checkExhausted() {
-    if (eof()) throw EOFException("Unexpected EOF while reading UTF-8 line")
+    if (exhausted()) throw EOFException("Unexpected EOF while reading UTF-8 line")
 }
diff --git a/core/commonMain/src/kotlinx/io/text/TextInputObsolete.kt b/core/commonMain/src/kotlinx/io/text/TextInputObsolete.kt
@@ -107,7 +107,7 @@ private inline fun Input.decodeUtf8Chars(consumer: (Char) -> Boolean): Int {
     var state = STATE_UTF_8
     var count = 0
 
-    while (state != STATE_FINISH && !eof()) {
+    while (state != STATE_FINISH && !exhausted()) {
         readBufferRange { buffer, startOffset, endOffset ->
             for (offset in startOffset until endOffset) {
                 val byte = buffer.loadByteAt(offset).toInt() and 0xff
diff --git a/core/commonTest/src/kotlinx/io/InputOutputTest.common.kt b/core/commonTest/src/kotlinx/io/InputOutputTest.common.kt
@@ -96,7 +96,7 @@ class InputOutputTest {
         checkException { ErrorInput.preview { } }
         checkException { ErrorInput.prefetch(1) }
         checkException { ErrorInput.discardExact(1) }
-        checkException { ErrorInput.eof() }
+        checkException { ErrorInput.exhausted() }
         checkException {
             ErrorInput.readAvailableTo(
                 object : Output() {
@@ -124,7 +124,7 @@ class InputOutputTest {
 
         val count = input.copyTo(output)
 
-        assertTrue(input.eof())
+        assertTrue(input.exhausted())
         assertEquals(content.size, count)
 
         assertArrayEquals(content, output.toByteArray())
@@ -138,7 +138,7 @@ class InputOutputTest {
 
         val count = input.copyTo(output, size)
 
-        assertTrue(!input.eof())
+        assertTrue(!input.exhausted())
         assertEquals(size, count)
 
         assertArrayEquals(content.sliceArray(0 until size), output.toByteArray())
diff --git a/core/commonTest/src/kotlinx/io/InputPrimitivesTest.kt b/core/commonTest/src/kotlinx/io/InputPrimitivesTest.kt
@@ -30,7 +30,7 @@ class InputPrimitivesTest {
         assertReadLong(0x0001020304050607)
         assertReadLong(0x08090A0B0C0D0E0F)
         assertReadLong(0x1011121314151617)
-        assertFalse(eof(), "EOF")
+        assertFalse(exhausted(), "EOF")
         assertFails { readLong() }
     }
 
@@ -39,7 +39,7 @@ class InputPrimitivesTest {
         assertReadULong(0x7071727374757677u)
         assertReadULong(0x78797a7b7c7d7e7fu)
         assertReadULong(0x8081828384858687u)
-        assertFalse(eof(), "EOF")
+        assertFalse(exhausted(), "EOF")
         assertFails { readULong() }
     }
 
@@ -48,7 +48,7 @@ class InputPrimitivesTest {
         assertReadInt(0x00010203)
         assertReadInt(0x04050607)
         assertReadInt(0x08090a0b)
-        assertFalse(eof(), "EOF")
+        assertFalse(exhausted(), "EOF")
         assertFails { readInt() }
     }
 
@@ -57,7 +57,7 @@ class InputPrimitivesTest {
         assertReadUInt(0x00010203u)
         assertReadUInt(0x04050607u)
         assertReadUInt(0x08090a0bu)
-        assertFalse(eof(), "EOF")
+        assertFalse(exhausted(), "EOF")
         assertFails { readInt() }
     }
 
@@ -66,7 +66,7 @@ class InputPrimitivesTest {
         assertReadShort(0x0001)
         assertReadShort(0x0203)
         assertReadShort(0x0405)
-        assertFalse(eof(), "EOF")
+        assertFalse(exhausted(), "EOF")
         assertFails { readShort() }
     }
 
@@ -75,7 +75,7 @@ class InputPrimitivesTest {
         assertReadUShort(0x0001u)
         assertReadUShort(0x0203u)
         assertReadUShort(0x0405u)
-        assertFalse(eof(), "EOF")
+        assertFalse(exhausted(), "EOF")
         assertFails { readShort() }
     }
 
@@ -84,7 +84,7 @@ class InputPrimitivesTest {
         assertReadByte(0x0)
         assertReadByte(0x1)
         assertReadByte(0x2)
-        assertTrue(eof(), "EOF")
+        assertTrue(exhausted(), "EOF")
         assertFails { readByte() }
     }
 
@@ -93,7 +93,7 @@ class InputPrimitivesTest {
         assertReadUByte(0x0u)
         assertReadUByte(0x1u)
         assertReadUByte(0x2u)
-        assertTrue(eof(), "EOF")
+        assertTrue(exhausted(), "EOF")
         assertFails { readUByte() }
     }
 
diff --git a/core/commonTest/src/kotlinx/io/LimitingInputTest.kt b/core/commonTest/src/kotlinx/io/LimitingInputTest.kt
@@ -1,6 +1,5 @@
 package kotlinx.io
 
-import kotlinx.io.*
 import kotlinx.io.buffer.*
 import kotlinx.io.text.*
 import kotlin.test.*
@@ -30,7 +29,7 @@ class LimitingInputTest {
     @Test
     fun testZeroLimit() {
         val input = StringInput("long\nlong\nline").limit(0)
-        assertTrue(input.eof())
+        assertTrue(input.exhausted())
     }
 
     @Test
diff --git a/core/commonTest/src/kotlinx/io/OutputTest.kt b/core/commonTest/src/kotlinx/io/OutputTest.kt
@@ -15,12 +15,12 @@ class OutputTest {
             writeInt(0x00010203)
         }
         bytes.input().apply {
-            assertFalse(eof())
+            assertFalse(exhausted())
             assertReadLong(0x0001020304050607)
             assertReadLong(0x08090A0B0C0D0E0F)
             assertReadInt(0x08090A0B)
             assertReadInt(0x00010203)
-            assertTrue(eof())
+            assertTrue(exhausted())
         }
     }
 
@@ -34,13 +34,13 @@ class OutputTest {
             writeInt(0xDEAD) // by writing unit tests
         }
         bytes.input().apply {
-            assertFalse(eof())
+            assertFalse(exhausted())
             assertReadByte(0xFF.toByte())
             assertReadInt(0x08090A0B)
             assertReadInt(0x00010203)
             assertReadInt(0xAB023F3)
             assertReadInt(0xDEAD)
-            assertTrue(eof())
+            assertTrue(exhausted())
         }
     }
 
diff --git a/core/commonTest/src/kotlinx/io/bytes/BytesTest.kt b/core/commonTest/src/kotlinx/io/bytes/BytesTest.kt
@@ -75,7 +75,7 @@ class BytesTest {
 
             assertEquals("OK", readUtf8Line())
             assertEquals("1|2|3", readUtf8Line())
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
@@ -85,7 +85,7 @@ class BytesTest {
             writeByteArray(ByteArray(9999))
         }.useInput {
             readByteArray(ByteArray(9999))
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
@@ -96,7 +96,7 @@ class BytesTest {
         }.useInput {
             readByteArray(ByteArray(3))
             assertEquals("123", readUtf8Line())
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
@@ -107,7 +107,7 @@ class BytesTest {
         }.useInput {
             readByteArray(ByteArray(3))
             assertEquals("123", readUtf8String(3))
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
@@ -119,7 +119,7 @@ class BytesTest {
             assertFailsWith<EOFException> {
                 readByteArray(ByteArray(1000))
             }
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
@@ -129,7 +129,7 @@ class BytesTest {
             writeByteArray(ByteArray(99999))
         }.useInput {
             discardExact(99999)
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
 
     }
@@ -142,7 +142,7 @@ class BytesTest {
         }.useInput {
             readByteArray(ByteArray(99999 + 3))
             assertEquals("123", readUtf8Line())
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
@@ -155,7 +155,7 @@ class BytesTest {
         }.useInput {
             readByteArray(ByteArray(PACKET_BUFFER_SIZE - 1))
             assertEquals(0x01010101, readInt())
-            assertTrue { eof() }
+            assertTrue { exhausted() }
         }
     }
 
diff --git a/core/commonTest/src/kotlinx/io/text/LinesTest.kt b/core/commonTest/src/kotlinx/io/text/LinesTest.kt
@@ -2,7 +2,6 @@ package kotlinx.io.text
 
 import kotlinx.io.*
 import kotlinx.io.buffer.*
-import kotlinx.io.text.*
 import kotlin.test.*
 
 class LinesTest {
@@ -53,7 +52,7 @@ class LinesTest {
     private fun testLineByLine(data: ByteArray, expectedLines: List<String>) {
         val input = ByteArrayInput(data)
         val result = ArrayList<String>()
-        while (!input.eof()) {
+        while (!input.exhausted()) {
             result += input.readUtf8Line()
         }
         assertEquals(expectedLines, result)
diff --git a/core/commonTest/src/kotlinx/io/text/OutputStringTest.kt b/core/commonTest/src/kotlinx/io/text/OutputStringTest.kt
@@ -19,7 +19,7 @@ open class OutputStringTest {
         val input = bytes.input()
         val read = UByteArray(expected.size)
         input.readByteArray(read)
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
         assertEquals(expected.contentToString(), read.contentToString())
     }
 
@@ -36,7 +36,7 @@ open class OutputStringTest {
         val input = bytes.input()
         val read = UByteArray(expected.size)
         input.readByteArray(read)
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
         assertEquals(expected.contentToString(), read.contentToString())
     }
 
@@ -65,7 +65,7 @@ open class OutputStringTest {
         val input = bytes.input()
         val read = UByteArray(expected.size)
         input.readByteArray(read)
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
         assertEquals(expected.contentToString(), read.contentToString())
     }
 
@@ -76,7 +76,7 @@ open class OutputStringTest {
         }.input()
 
         assertEquals("ABC\u0422", input.readUtf8String(4))
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
     }
 
     @Test
@@ -87,7 +87,7 @@ open class OutputStringTest {
 
         try {
             assertEquals("1", input.readUtf8String(1))
-            assertTrue(input.eof(), "EOF")
+            assertTrue(input.exhausted(), "EOF")
         } finally {
             input.close()
         }
@@ -106,7 +106,7 @@ open class OutputStringTest {
         counts.add(input.readUtf8StringUntilDelimitersTo(sb, "|,."))
         counts.add(input.readUtf8StringUntilDelimitersTo(sb, "|,."))
         counts.add(input.readUtf8StringUntilDelimitersTo(sb, "|,."))
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
         assertEquals("1234", sb.toString())
         assertEquals(listOf(1, 2, 0, 1), counts)
     }
@@ -123,7 +123,7 @@ open class OutputStringTest {
         counts.add(input.readUtf8StringUntilDelimitersTo(sb, "|,."))
         counts.add(input.readUtf8StringUntilDelimitersTo(sb, "|,."))
         counts.add(input.readUtf8StringUntilDelimitersTo(sb, "|,."))
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
         assertEquals("\u0422\u0423\u0424", sb.toString())
         assertEquals(listOf(1, 1, 1), counts)
     }
@@ -138,7 +138,7 @@ open class OutputStringTest {
         assertEquals("22", input.readUtf8Line())
         assertEquals("333", input.readUtf8Line())
         assertEquals("4444", input.readUtf8Line())
-        assertTrue(input.eof(), "EOF")
+        assertTrue(input.exhausted(), "EOF")
     }
 }
 
diff --git a/playground/jvmMain/src/kotlinx/io/gzip/GzipInput.kt b/playground/jvmMain/src/kotlinx/io/gzip/GzipInput.kt
@@ -8,7 +8,7 @@ import java.util.zip.*
 class GzipInput(private val original: Input) : Input() {
     private val inputStream = object : InputStream() {
         override fun read(): Int {
-            if (original.eof()) return -1
+            if (original.exhausted()) return -1
             return original.readByte().toInt()
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public fun Input.readUtf8Lines(): List<String> {`
`25`	`25`	`checkExhausted()`
`26`	`26`	`val list = ArrayList<String>()`
`27`	`27`	`use {`
`28`		`- while (!eof()) {`
	`28`	`+ while (!exhausted()) {`
`29`	`29`	`list += readUtf8Line()`
`30`	`30`	`}`
`31`	`31`	`}`
`@@ -40,12 +40,12 @@ public fun Input.readUtf8Lines(): List<String> {`
`40`	`40`	`*/`
`41`	`41`	`public inline fun Input.forEachUtf8Line(action: (String) -> Unit) {`
`42`	`42`	`use {`
`43`		`- while (!eof()) {`
	`43`	`+ while (!exhausted()) {`
`44`	`44`	`action(readUtf8Line())`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`private fun Input.checkExhausted() {`
`50`		`- if (eof()) throw EOFException("Unexpected EOF while reading UTF-8 line")`
	`50`	`+ if (exhausted()) throw EOFException("Unexpected EOF while reading UTF-8 line")`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,12 +15,12 @@ class OutputTest {`
`15`	`15`	`writeInt(0x00010203)`
`16`	`16`	`}`
`17`	`17`	`bytes.input().apply {`
`18`		`- assertFalse(eof())`
	`18`	`+ assertFalse(exhausted())`
`19`	`19`	`assertReadLong(0x0001020304050607)`
`20`	`20`	`assertReadLong(0x08090A0B0C0D0E0F)`
`21`	`21`	`assertReadInt(0x08090A0B)`
`22`	`22`	`assertReadInt(0x00010203)`
`23`		`- assertTrue(eof())`
	`23`	`+ assertTrue(exhausted())`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`@@ -34,13 +34,13 @@ class OutputTest {`
`34`	`34`	`writeInt(0xDEAD) // by writing unit tests`
`35`	`35`	`}`
`36`	`36`	`bytes.input().apply {`
`37`		`- assertFalse(eof())`
	`37`	`+ assertFalse(exhausted())`
`38`	`38`	`assertReadByte(0xFF.toByte())`
`39`	`39`	`assertReadInt(0x08090A0B)`
`40`	`40`	`assertReadInt(0x00010203)`
`41`	`41`	`assertReadInt(0xAB023F3)`
`42`	`42`	`assertReadInt(0xDEAD)`
`43`		`- assertTrue(eof())`
	`43`	`+ assertTrue(exhausted())`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ class BytesTest {`
`75`	`75`
`76`	`76`	`assertEquals("OK", readUtf8Line())`
`77`	`77`	`assertEquals("1\|2\|3", readUtf8Line())`
`78`		`- assertTrue { eof() }`
	`78`	`+ assertTrue { exhausted() }`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`@@ -85,7 +85,7 @@ class BytesTest {`
`85`	`85`	`writeByteArray(ByteArray(9999))`
`86`	`86`	`}.useInput {`
`87`	`87`	`readByteArray(ByteArray(9999))`
`88`		`- assertTrue { eof() }`
	`88`	`+ assertTrue { exhausted() }`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`@@ -96,7 +96,7 @@ class BytesTest {`
`96`	`96`	`}.useInput {`
`97`	`97`	`readByteArray(ByteArray(3))`
`98`	`98`	`assertEquals("123", readUtf8Line())`
`99`		`- assertTrue { eof() }`
	`99`	`+ assertTrue { exhausted() }`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`@@ -107,7 +107,7 @@ class BytesTest {`
`107`	`107`	`}.useInput {`
`108`	`108`	`readByteArray(ByteArray(3))`
`109`	`109`	`assertEquals("123", readUtf8String(3))`
`110`		`- assertTrue { eof() }`
	`110`	`+ assertTrue { exhausted() }`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`@@ -119,7 +119,7 @@ class BytesTest {`
`119`	`119`	`assertFailsWith<EOFException> {`
`120`	`120`	`readByteArray(ByteArray(1000))`
`121`	`121`	`}`
`122`		`- assertTrue { eof() }`
	`122`	`+ assertTrue { exhausted() }`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`
`@@ -129,7 +129,7 @@ class BytesTest {`
`129`	`129`	`writeByteArray(ByteArray(99999))`
`130`	`130`	`}.useInput {`
`131`	`131`	`discardExact(99999)`
`132`		`- assertTrue { eof() }`
	`132`	`+ assertTrue { exhausted() }`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`}`
`@@ -142,7 +142,7 @@ class BytesTest {`
`142`	`142`	`}.useInput {`
`143`	`143`	`readByteArray(ByteArray(99999 + 3))`
`144`	`144`	`assertEquals("123", readUtf8Line())`
`145`		`- assertTrue { eof() }`
	`145`	`+ assertTrue { exhausted() }`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`@@ -155,7 +155,7 @@ class BytesTest {`
`155`	`155`	`}.useInput {`
`156`	`156`	`readByteArray(ByteArray(PACKET_BUFFER_SIZE - 1))`
`157`	`157`	`assertEquals(0x01010101, readInt())`
`158`		`- assertTrue { eof() }`
	`158`	`+ assertTrue { exhausted() }`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import java.util.zip.*`
`8`	`8`	`class GzipInput(private val original: Input) : Input() {`
`9`	`9`	`private val inputStream = object : InputStream() {`
`10`	`10`	`override fun read(): Int {`
`11`		`- if (original.eof()) return -1`
	`11`	`+ if (original.exhausted()) return -1`
`12`	`12`	`return original.readByte().toInt()`
`13`	`13`	`}`
`14`	`14`	`}`