Merge pull request #67 from touchlab/kpg/visibility_and_api

kpgalligan · web-flow · commit 9d202b57c830 · 2022-03-26T18:22:56.000-04:00
Kpg/visibility and api
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -3,11 +3,6 @@ rootProject.name = "sqliter"
 include(":sqliter-driver")
 
 pluginManagement {
-  repositories {
-    google()
-    gradlePluginPortal()
-    maven(url = "https://oss.sonatype.org/content/repositories/snapshots/")
-  }
   val KOTLIN_VERSION: String by settings
   plugins {
     kotlin("multiplatform") version KOTLIN_VERSION
diff --git a/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/concurrency/Lock.kt b/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/concurrency/Lock.kt
@@ -2,7 +2,18 @@ package co.touchlab.sqliter.concurrency
 
 import platform.Foundation.NSRecursiveLock
 
-actual typealias Lock = NSRecursiveLock
+internal actual class Lock actual constructor() {
+    private val l = NSRecursiveLock()
+    actual fun lock() {
+        l.lock()
+    }
+
+    actual fun unlock() {
+        l.unlock()
+    }
+
+    actual fun tryLock(): Boolean = l.tryLock()
+}
 
 @Suppress("NOTHING_TO_INLINE")
-actual inline fun Lock.close() {}
+internal actual inline fun Lock.close() {}
diff --git a/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/util/usleep.kt b/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/util/usleep.kt
@@ -1,5 +1,5 @@
 package co.touchlab.sqliter.util
 
-actual fun usleep(seconds: UInt) {
+internal actual fun usleep(seconds: UInt) {
     platform.posix.usleep(seconds)
 }
diff --git a/sqliter-driver/src/linuxX64Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt b/sqliter-driver/src/linuxX64Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt
@@ -10,7 +10,7 @@ import platform.posix.*
  * A simple lock.
  * Implementations of this class should be re-entrant.
  */
-actual class Lock actual constructor() {
+internal actual class Lock actual constructor() {
     private val arena = Arena()
     private val attr = arena.alloc<pthread_mutexattr_t>()
     private val mutex = arena.alloc<pthread_mutex_t>()
@@ -39,6 +39,6 @@ actual class Lock actual constructor() {
     }
 }
 
-actual inline fun Lock.close() {
+internal actual inline fun Lock.close() {
     internalClose()
 }
diff --git a/sqliter-driver/src/linuxX64Main/kotlin/co/touchlab/sqliter/util/usleep.kt b/sqliter-driver/src/linuxX64Main/kotlin/co/touchlab/sqliter/util/usleep.kt
@@ -3,6 +3,6 @@ package co.touchlab.sqliter.util
 /**
  * Wrapper for platform.posix.usleep
  */
-actual fun usleep(seconds: UInt) {
+internal actual fun usleep(seconds: UInt) {
     platform.posix.usleep(seconds)
 }
diff --git a/sqliter-driver/src/mingwMain/kotlin/co/touchlab/sqliter/util/usleep.kt b/sqliter-driver/src/mingwMain/kotlin/co/touchlab/sqliter/util/usleep.kt
@@ -3,6 +3,6 @@ package co.touchlab.sqliter.util
 /**
  * Wrapper for platform.posix.usleep
  */
-actual fun usleep(seconds: UInt) {
+internal actual fun usleep(seconds: UInt) {
     platform.posix.usleep(seconds)
 }
diff --git a/sqliter-driver/src/mingwX64Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt b/sqliter-driver/src/mingwX64Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt
@@ -20,7 +20,7 @@ import platform.posix.pthread_mutexattr_tVar
  * A simple lock.
  * Implementations of this class should be re-entrant.
  */
-actual class Lock actual constructor() {
+internal actual class Lock actual constructor() {
     private val arena = Arena()
     private val attr = arena.alloc<pthread_mutexattr_tVar>()
     private val mutex = arena.alloc<pthread_mutex_tVar>()
@@ -49,6 +49,6 @@ actual class Lock actual constructor() {
     }
 }
 
-actual inline fun Lock.close() {
+internal actual inline fun Lock.close() {
     internalClose()
 }
diff --git a/sqliter-driver/src/mingwX86Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt b/sqliter-driver/src/mingwX86Main/kotlin/co/touchlab/sqliter/concurrency/Lock.kt
@@ -20,7 +20,7 @@ import platform.posix.pthread_mutexattr_tVar
  * A simple lock.
  * Implementations of this class should be re-entrant.
  */
-actual class Lock actual constructor() {
+internal actual class Lock actual constructor() {
     private val arena = Arena()
     private val attr = arena.alloc<pthread_mutexattr_tVar>()
     private val mutex = arena.alloc<pthread_mutex_tVar>()
@@ -49,6 +49,6 @@ actual class Lock actual constructor() {
     }
 }
 
-actual inline fun Lock.close() {
+internal actual inline fun Lock.close() {
     internalClose()
 }
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/DatabaseConfiguration.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/DatabaseConfiguration.kt
@@ -18,7 +18,6 @@ package co.touchlab.sqliter
 
 import co.touchlab.sqliter.interop.Logger
 
-
 data class DatabaseConfiguration(
     val name: String?,
     val version: Int,
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/concurrency/ConcurrentDatabaseConnection.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/concurrency/ConcurrentDatabaseConnection.kt
@@ -21,12 +21,13 @@ import co.touchlab.sqliter.DatabaseConnection
 import co.touchlab.sqliter.FieldType
 import co.touchlab.sqliter.Statement
 
-class ConcurrentDatabaseConnection(private val delegateConnection:DatabaseConnection):DatabaseConnection{
+internal class ConcurrentDatabaseConnection(private val delegateConnection: DatabaseConnection) : DatabaseConnection {
     private val accessLock = Lock()
 
     override fun rawExecSql(sql: String) = accessLock.withLock { delegateConnection.rawExecSql(sql) }
 
-    override fun createStatement(sql: String): Statement = accessLock.withLock { ConcurrentStatement(delegateConnection.createStatement(sql)) }
+    override fun createStatement(sql: String): Statement =
+        accessLock.withLock { ConcurrentStatement(delegateConnection.createStatement(sql)) }
 
     override fun beginTransaction() = accessLock.withLock { delegateConnection.beginTransaction() }
 
@@ -39,7 +40,7 @@ class ConcurrentDatabaseConnection(private val delegateConnection:DatabaseConnec
     override val closed: Boolean
         get() = delegateConnection.closed
 
-    inner class ConcurrentCursor(private val delegateCursor: Cursor):Cursor{
+    inner class ConcurrentCursor(private val delegateCursor: Cursor) : Cursor {
         override fun next(): Boolean = accessLock.withLock { delegateCursor.next() }
 
         override fun isNull(index: Int): Boolean = accessLock.withLock { delegateCursor.isNull(index) }
@@ -66,7 +67,7 @@ class ConcurrentDatabaseConnection(private val delegateConnection:DatabaseConnec
 
     }
 
-    inner class ConcurrentStatement(internal val delegateStatement:Statement):Statement{
+    inner class ConcurrentStatement(internal val delegateStatement: Statement) : Statement {
         override fun execute() = accessLock.withLock { delegateStatement.execute() }
 
         override fun executeInsert(): Long = accessLock.withLock { delegateStatement.executeInsert() }
@@ -83,14 +84,19 @@ class ConcurrentDatabaseConnection(private val delegateConnection:DatabaseConnec
 
         override fun bindNull(index: Int) = accessLock.withLock { delegateStatement.bindNull(index) }
 
-        override fun bindLong(index: Int, value: Long) = accessLock.withLock { delegateStatement.bindLong(index, value) }
+        override fun bindLong(index: Int, value: Long) =
+            accessLock.withLock { delegateStatement.bindLong(index, value) }
 
-        override fun bindDouble(index: Int, value: Double) = accessLock.withLock { delegateStatement.bindDouble(index, value) }
+        override fun bindDouble(index: Int, value: Double) =
+            accessLock.withLock { delegateStatement.bindDouble(index, value) }
 
-        override fun bindString(index: Int, value: String) = accessLock.withLock { delegateStatement.bindString(index, value) }
+        override fun bindString(index: Int, value: String) =
+            accessLock.withLock { delegateStatement.bindString(index, value) }
 
-        override fun bindBlob(index: Int, value: ByteArray) = accessLock.withLock { delegateStatement.bindBlob(index, value) }
+        override fun bindBlob(index: Int, value: ByteArray) =
+            accessLock.withLock { delegateStatement.bindBlob(index, value) }
 
-        override fun bindParameterIndex(paramName: String): Int = accessLock.withLock { delegateStatement.bindParameterIndex(paramName) }
+        override fun bindParameterIndex(paramName: String): Int =
+            accessLock.withLock { delegateStatement.bindParameterIndex(paramName) }
     }
 }
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/concurrency/Lock.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/concurrency/Lock.kt
@@ -4,15 +4,15 @@ package co.touchlab.sqliter.concurrency
  * A simple lock.
  * Implementations of this class should be re-entrant.
  */
-expect class Lock() {
+internal expect class Lock() {
     fun lock()
     fun unlock()
     fun tryLock(): Boolean
 }
 
-expect inline fun Lock.close()
+internal expect inline fun Lock.close()
 
-inline fun <T> Lock.withLock(block: () -> T): T {
+internal inline fun <T> Lock.withLock(block: () -> T): T {
     lock()
     try {
         return block()
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/concurrency/SingleThreadDatabaseConnection.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/concurrency/SingleThreadDatabaseConnection.kt
@@ -19,7 +19,7 @@ package co.touchlab.sqliter.concurrency
 import co.touchlab.sqliter.DatabaseConnection
 import kotlin.native.concurrent.ensureNeverFrozen
 
-class SingleThreadDatabaseConnection(delegateConnection: DatabaseConnection):DatabaseConnection by delegateConnection
+internal class SingleThreadDatabaseConnection(delegateConnection: DatabaseConnection):DatabaseConnection by delegateConnection
 {
     init {
         if (Platform.memoryModel == MemoryModel.STRICT)
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/ActualSqliteStatement.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/ActualSqliteStatement.kt
@@ -6,7 +6,7 @@ import co.touchlab.sqliter.util.usleep
 
 expect inline fun bytesToString(bv:CPointer<ByteVar>):String
 
-class ActualSqliteStatement(private val db: SqliteDatabase, internal val stmtPointer: SqliteStatementPointer) :
+internal class ActualSqliteStatement(private val db: SqliteDatabase, private val stmtPointer: SqliteStatementPointer) :
     SqliteStatement {
 
     //Cursor methods
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/Logger.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/Logger.kt
@@ -1,7 +1,5 @@
 package co.touchlab.sqliter.interop
 
-internal const val LOG_TRACE = true
-
 interface Logger {
     fun trace(message: String)
     val vActive:Boolean
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/SQLiteException.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/SQLiteException.kt
@@ -1,8 +1,8 @@
 package co.touchlab.sqliter.interop
 
-open class SQLiteException(message: String, private val config: SqliteDatabaseConfig) : Exception(message)
+open class SQLiteException internal constructor(message: String, private val config: SqliteDatabaseConfig) : Exception(message)
 
-class SQLiteExceptionErrorCode(message: String, config: SqliteDatabaseConfig, private val errorCode: Int) : SQLiteException(message, config) {
+class SQLiteExceptionErrorCode internal constructor(message: String, config: SqliteDatabaseConfig, private val errorCode: Int) : SQLiteException(message, config) {
     val errorType: SqliteErrorType by lazy {
         val checkErrorCode = errorCode and 0xff
         SqliteErrorType.values().find { it.code == checkErrorCode }
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/SqliteDatabase.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/SqliteDatabase.kt
@@ -5,7 +5,7 @@ import cnames.structs.sqlite3_stmt
 import kotlinx.cinterop.*
 import co.touchlab.sqliter.sqlite3.*
 
-class SqliteDatabase(path:String, label:String, val logger: Logger, private val verboseDataCalls: Boolean, val dbPointer:SqliteDatabasePointer) {
+internal class SqliteDatabase(path:String, label:String, val logger: Logger, private val verboseDataCalls: Boolean, val dbPointer:SqliteDatabasePointer) {
     val config = SqliteDatabaseConfig(path, label)
 
     fun prepareStatement(sqlString: String): SqliteStatement {
@@ -53,15 +53,15 @@ class SqliteDatabase(path:String, label:String, val logger: Logger, private val
     }
 }
 
-data class SqliteDatabaseConfig(val path:String, val label:String)
+internal data class SqliteDatabaseConfig(val path:String, val label:String)
 
-enum class OpenFlags {
+internal enum class OpenFlags {
     CREATE_IF_NECESSARY,
     OPEN_READONLY
 }
 
 @Suppress("UNUSED_PARAMETER")
-fun dbOpen(
+internal fun dbOpen(
     path: String,
     openFlags: List<OpenFlags>,
     label: String,
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/SqliteStatement.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/SqliteStatement.kt
@@ -1,6 +1,6 @@
 package co.touchlab.sqliter.interop
 
-interface SqliteStatement {
+internal interface SqliteStatement {
     //Cursor methods
     fun isNull(index: Int): Boolean
     fun columnGetLong(columnIndex: Int): Long
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/TracingSqliteStatement.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/interop/TracingSqliteStatement.kt
@@ -1,6 +1,6 @@
 package co.touchlab.sqliter.interop
 
-class TracingSqliteStatement(private val logger: Logger, private val delegate:SqliteStatement):SqliteStatement {
+internal class TracingSqliteStatement(private val logger: Logger, private val delegate:SqliteStatement):SqliteStatement {
     private fun <T> logWrapper(name:String, params: List<Any?>, block:()->T):T{
         val result = block()
         logger.vWrite("statement.$name" + params.joinToString(separator = ", ", prefix = "(", postfix = ")") + "->" + result)
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/native/NativeDatabaseConnection.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/native/NativeDatabaseConnection.kt
@@ -24,14 +24,14 @@ import co.touchlab.sqliter.util.maybeFreeze
 import kotlin.native.concurrent.AtomicInt
 import kotlin.native.concurrent.AtomicReference
 
-class NativeDatabaseConnection(
+class NativeDatabaseConnection internal constructor(
     val dbManager: NativeDatabaseManager,
-    val sqliteDatabase: SqliteDatabase
+    private val sqliteDatabase: SqliteDatabase
 ) : DatabaseConnection {
 
     private val transLock = Lock()
 
-    internal val transaction = AtomicReference<Transaction?>(null)
+    private val transaction = AtomicReference<Transaction?>(null)
     private val closedFlag = AtomicInt(0)
 
     data class Transaction(val successful: Boolean)
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/native/NativeStatement.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/native/NativeStatement.kt
@@ -20,7 +20,7 @@ import co.touchlab.sqliter.Cursor
 import co.touchlab.sqliter.Statement
 import co.touchlab.sqliter.interop.*
 
-class NativeStatement(
+class NativeStatement internal constructor(
     internal val connection: NativeDatabaseConnection,
     internal val sqliteStatement: SqliteStatement,
     sql: String
diff --git a/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/util/usleep.kt b/sqliter-driver/src/nativeCommonMain/kotlin/co/touchlab/sqliter/util/usleep.kt
@@ -4,4 +4,4 @@ package co.touchlab.sqliter.util
  * Wrapper for platform.posix.usleep
  * Commonization issue can be tracked https://youtrack.jetbrains.com/issue/KT-48278
  */
-expect fun usleep(seconds: UInt)
+internal expect fun usleep(seconds: UInt)

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`package co.touchlab.sqliter.util`
`2`	`2`
`3`		`-actual fun usleep(seconds: UInt) {`
	`3`	`+internal actual fun usleep(seconds: UInt) {`
`4`	`4`	`platform.posix.usleep(seconds)`
`5`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import platform.posix.*`
`10`	`10`	`* A simple lock.`
`11`	`11`	`* Implementations of this class should be re-entrant.`
`12`	`12`	`*/`
`13`		`-actual class Lock actual constructor() {`
	`13`	`+internal actual class Lock actual constructor() {`
`14`	`14`	`private val arena = Arena()`
`15`	`15`	`private val attr = arena.alloc<pthread_mutexattr_t>()`
`16`	`16`	`private val mutex = arena.alloc<pthread_mutex_t>()`
`@@ -39,6 +39,6 @@ actual class Lock actual constructor() {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-actual inline fun Lock.close() {`
	`42`	`+internal actual inline fun Lock.close() {`
`43`	`43`	`internalClose()`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,6 @@ package co.touchlab.sqliter.util`
`3`	`3`	`/**`
`4`	`4`	`* Wrapper for platform.posix.usleep`
`5`	`5`	`*/`
`6`		`-actual fun usleep(seconds: UInt) {`
	`6`	`+internal actual fun usleep(seconds: UInt) {`
`7`	`7`	`platform.posix.usleep(seconds)`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ import platform.posix.pthread_mutexattr_tVar`
`20`	`20`	`* A simple lock.`
`21`	`21`	`* Implementations of this class should be re-entrant.`
`22`	`22`	`*/`
`23`		`-actual class Lock actual constructor() {`
	`23`	`+internal actual class Lock actual constructor() {`
`24`	`24`	`private val arena = Arena()`
`25`	`25`	`private val attr = arena.alloc<pthread_mutexattr_tVar>()`
`26`	`26`	`private val mutex = arena.alloc<pthread_mutex_tVar>()`
`@@ -49,6 +49,6 @@ actual class Lock actual constructor() {`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`-actual inline fun Lock.close() {`
	`52`	`+internal actual inline fun Lock.close() {`
`53`	`53`	`internalClose()`
`54`	`54`	`}`