updating from fast double parser branch

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/parse.kt

@@ -33,7 +33,7 @@ import org.jetbrains.kotlinx.dataframe.hasNulls
 import org.jetbrains.kotlinx.dataframe.impl.canParse
 import org.jetbrains.kotlinx.dataframe.impl.catchSilent
 import org.jetbrains.kotlinx.dataframe.impl.createStarProjectedType
-import org.jetbrains.kotlinx.dataframe.impl.io.DoubleParser
+import org.jetbrains.kotlinx.dataframe.impl.io.FastDoubleParser
 import org.jetbrains.kotlinx.dataframe.impl.javaDurationCanParse
 import org.jetbrains.kotlinx.dataframe.io.isURL
 import org.jetbrains.kotlinx.dataframe.io.readJsonStr
@@ -293,12 +293,12 @@ internal object Parsers : GlobalParserOptions {
     ): StringParserWithFormat<T> = StringParserWithFormat(typeOf<T>(), coveredBy, body)
 
     private val parserToDoubleWithOptions = stringParserWithOptions { options ->
-        val doubleParser = DoubleParser(options ?: ParserOptions())
-        val parser = { it: String -> doubleParser.parseOrNull(it) }
+        val fastDoubleParser = FastDoubleParser(options ?: ParserOptions())
+        val parser = { it: String -> fastDoubleParser.parseOrNull(it) }
         parser
     }
 
-    private val posixDoubleParser = DoubleParser(
+    private val posixDoubleParser = FastDoubleParser(
         ParserOptions(locale = Locale.forLanguageTag("C.UTF-8")),
     )
 

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DoubleParser.kt renamed to core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/FastDoubleParser.kt

@@ -22,21 +22,22 @@ private val logger = KotlinLogging.logger {}
  * support different locales and fallback symbols.
  *
  * Public, so it can be used in other modules.
- * Open, so it may be modified.
  *
  * @param parserOptions can be supplied to configure the parser.
  *   We'll only use [ParserOptions.locale] and [ParserOptions.useFastDoubleParser].
  */
 @Suppress("ktlint:standard:comment-wrapping")
-public open class DoubleParser(private val parserOptions: ParserOptions) {
+public class FastDoubleParser(private val parserOptions: ParserOptions) {
 
-    protected val locale: Locale = parserOptions.locale ?: Locale.getDefault()
-    protected val supportedFastCharsets: Set<Charset> = setOf(Charsets.UTF_8, Charsets.ISO_8859_1, Charsets.US_ASCII)
+    private val supportedFastCharsets = setOf(Charsets.UTF_8, Charsets.ISO_8859_1, Charsets.US_ASCII)
 
-    protected val localDecimalFormatSymbols: DecimalFormatSymbols = DecimalFormatSymbols.getInstance(locale)
-    protected val fallbackDecimalFormatSymbols: DecimalFormatSymbols = DecimalFormatSymbols.getInstance(Locale.ROOT)
+    private val locale: Locale = parserOptions.locale ?: Locale.getDefault()
+    private val fallbackLocale: Locale = Locale.ROOT
 
-    protected open val parser: ConfigurableDoubleParser =
+    private val localDecimalFormatSymbols: DecimalFormatSymbols = DecimalFormatSymbols.getInstance(locale)
+    private val fallbackDecimalFormatSymbols: DecimalFormatSymbols = DecimalFormatSymbols.getInstance(fallbackLocale)
+
+    private val parser: ConfigurableDoubleParser =
         ConfigurableDoubleParser(
             /* symbols = */ setupNumberFormatSymbols(),
             /* ignoreCase = */ true,
@@ -48,20 +49,20 @@ public open class DoubleParser(private val parserOptions: ParserOptions) {
      *
      * Fallback characters/strings are only added if they're not clashing with local characters/strings.
      */
-    protected fun setupNumberFormatSymbols(): NumberFormatSymbols {
+    private fun setupNumberFormatSymbols(): NumberFormatSymbols {
         // collect all chars and strings that are locale-specific such that we can check whether
         // fallback chars and strings are safe to add
-        val localChars = buildSet {
-            with(localDecimalFormatSymbols) {
+        val localChars = with(localDecimalFormatSymbols) {
+            buildSet {
                 add(decimalSeparator.lowercaseChar())
                 add(groupingSeparator.lowercaseChar())
                 add(minusSign.lowercaseChar())
                 add('+')
                 add(zeroDigit.lowercaseChar())
             }
         }
-        val localStrings = buildSet {
-            with(localDecimalFormatSymbols) {
+        val localStrings = with(localDecimalFormatSymbols) {
+            buildSet {
                 add(exponentSeparator.lowercase())
                 add(infinity.lowercase())
                 add(naN.lowercase())
@@ -137,7 +138,7 @@ public open class DoubleParser(private val parserOptions: ParserOptions) {
     }
 
     /** Fallback method for parsing doubles. */
-    protected open fun String.parseToDoubleOrNullFallback(): Double? =
+    private fun String.parseToDoubleOrNullFallback(): Double? =
         when (lowercase()) {
             "inf", "+inf", "infinity", "+infinity", "infty", "+infty", "∞", "+∞" -> Double.POSITIVE_INFINITY
 
@@ -168,7 +169,7 @@ public open class DoubleParser(private val parserOptions: ParserOptions) {
      * It uses the [fast double parser][ConfigurableDoubleParser] if [ParserOptions.useFastDoubleParser] is enabled,
      * else, or if that fails, it uses [parseToDoubleOrNullFallback].
      */
-    public open fun parseOrNull(
+    public fun parseOrNull(
         ba: ByteArray,
         offset: Int = 0,
         length: Int = ba.size,
@@ -195,7 +196,7 @@ public open class DoubleParser(private val parserOptions: ParserOptions) {
      * It uses the [fast double parser][ConfigurableDoubleParser] if [ParserOptions.useFastDoubleParser] is enabled,
      * else, or if that fails, it uses [parseToDoubleOrNullFallback].
      */
-    public open fun parseOrNull(cs: CharSequence): Double? {
+    public fun parseOrNull(cs: CharSequence): Double? {
         if (parserOptions.useFastDoubleParser) {
             try {
                 return parser.parseDouble(cs)
@@ -215,7 +216,7 @@ public open class DoubleParser(private val parserOptions: ParserOptions) {
      * It uses the [fast double parser][ConfigurableDoubleParser] if [ParserOptions.useFastDoubleParser] is enabled,
      * else, or if that fails, it uses [parseToDoubleOrNullFallback].
      */
-    public open fun parseOrNull(ca: CharArray, offset: Int = 0, length: Int = ca.size): Double? {
+    public fun parseOrNull(ca: CharArray, offset: Int = 0, length: Int = ca.size): Double? {
         if (parserOptions.useFastDoubleParser) {
             try {
                 return parser.parseDouble(ca, offset, length)

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/csv.kt

@@ -395,6 +395,7 @@ public fun DataFrame.Companion.readDelim(
             null -> column.tryParse(parserOptions)
 
             else -> {
+                // TODO use skipAllExcept
                 val parser = Parsers[colType.toKType()]!!
                 column.parse(parser, parserOptions)
             }

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/DoubleParserTests.kt renamed to core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/io/FastDoubleParserTests.kt

@@ -2,32 +2,34 @@ package org.jetbrains.kotlinx.dataframe.io
 
 import io.kotest.matchers.collections.shouldContainInOrder
 import org.jetbrains.kotlinx.dataframe.api.ParserOptions
-import org.jetbrains.kotlinx.dataframe.impl.io.DoubleParser
+import org.jetbrains.kotlinx.dataframe.impl.io.FastDoubleParser
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import java.util.Locale
 
-class DoubleParserTests {
+private const val LOG_LEVEL = "org.slf4j.simpleLogger.defaultLogLevel"
+
+class FastDoubleParserTests {
 
     private var loggerBefore: String? = null
 
     @Before
     fun setLogger() {
-        loggerBefore = System.getProperty("org.slf4j.simpleLogger.defaultLogLevel")
-        System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "debug")
+        loggerBefore = System.getProperty(LOG_LEVEL)
+        System.setProperty(LOG_LEVEL, "debug")
     }
 
     @After
     fun restoreLogger() {
         if (loggerBefore != null) {
-            System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", loggerBefore)
+            System.setProperty(LOG_LEVEL, loggerBefore)
         }
     }
 
     @Test
     fun `can fast parse doubles`() {
-        val parser = DoubleParser(ParserOptions(locale = Locale.ROOT, useFastDoubleParser = true))
+        val parser = FastDoubleParser(ParserOptions(locale = Locale.ROOT, useFastDoubleParser = true))
 
         val numbers = listOf(
             "+12.45",
@@ -67,7 +69,7 @@ class DoubleParserTests {
 
     @Test
     fun `can fast parse german locale`() {
-        val parser = DoubleParser(ParserOptions(locale = Locale.GERMANY, useFastDoubleParser = true))
+        val parser = FastDoubleParser(ParserOptions(locale = Locale.GERMANY, useFastDoubleParser = true))
 
         val numbers = listOf(
             "12,45",
@@ -97,7 +99,7 @@ class DoubleParserTests {
 
     @Test
     fun `can fast parse french locale`() {
-        val parser = DoubleParser(ParserOptions(locale = Locale.FRANCE, useFastDoubleParser = true))
+        val parser = FastDoubleParser(ParserOptions(locale = Locale.FRANCE, useFastDoubleParser = true))
 
         val numbers = listOf(
             "12,45",
@@ -127,7 +129,8 @@ class DoubleParserTests {
 
     @Test
     fun `can fast parse estonian locale`() {
-        val parser = DoubleParser(ParserOptions(locale = Locale.forLanguageTag("et-EE"), useFastDoubleParser = true))
+        val parser =
+            FastDoubleParser(ParserOptions(locale = Locale.forLanguageTag("et-EE"), useFastDoubleParser = true))
 
         val numbers = listOf(
             "12,45",

dataframe-csv/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/io/DataFrameCustomDoubleParser.kt

@@ -5,20 +5,20 @@ import io.deephaven.csv.tokenization.Tokenizer.CustomDoubleParser
 import org.jetbrains.kotlinx.dataframe.api.ParserOptions
 
 /**
- * Wrapper around [DoubleParser] so we can use it from Deephaven.
+ * Wrapper around [FastDoubleParser] so we can use it from Deephaven.
  */
 internal class DataFrameCustomDoubleParser(parserOptions: ParserOptions) : CustomDoubleParser {
 
-    private val doubleParser = DoubleParser(parserOptions)
+    private val fastDoubleParser = FastDoubleParser(parserOptions)
 
     override fun parse(bs: ByteSlice): Double =
         try {
-            doubleParser.parseOrNull(bs.data(), bs.begin(), bs.size())
+            fastDoubleParser.parseOrNull(bs.data(), bs.begin(), bs.size())
         } catch (e: Exception) {
             null
         } ?: throw NumberFormatException("Failed to parse double")
 
     override fun parse(cs: CharSequence): Double =
-        doubleParser.parseOrNull(cs.toString())
+        fastDoubleParser.parseOrNull(cs.toString())
             ?: throw NumberFormatException("Failed to parse double")
 }