chore(client): refactor closing / shutdown

Author: stainless-app[bot]

cas-parser-java-core/src/main/kotlin/com/cas_parser/api/client/CasParserClientAsyncImpl.kt

@@ -46,7 +46,7 @@ class CasParserClientAsyncImpl(private val clientOptions: ClientOptions) : CasPa
 
     override fun casGenerator(): CasGeneratorServiceAsync = casGenerator
 
-    override fun close() = clientOptions.httpClient.close()
+    override fun close() = clientOptions.close()
 
     class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
         CasParserClientAsync.WithRawResponse {

cas-parser-java-core/src/main/kotlin/com/cas_parser/api/client/CasParserClientImpl.kt

@@ -46,7 +46,7 @@ class CasParserClientImpl(private val clientOptions: ClientOptions) : CasParserC
 
     override fun casGenerator(): CasGeneratorService = casGenerator
 
-    override fun close() = clientOptions.httpClient.close()
+    override fun close() = clientOptions.close()
 
     class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
         CasParserClient.WithRawResponse {

cas-parser-java-core/src/main/kotlin/com/cas_parser/api/core/ClientOptions.kt

@@ -21,6 +21,8 @@ private constructor(
      * The HTTP client to use in the SDK.
      *
      * Use the one published in `cas-parser-java-client-okhttp` or implement your own.
+     *
+     * This class takes ownership of the client and closes it when closed.
      */
     @get:JvmName("httpClient") val httpClient: HttpClient,
     /**
@@ -157,6 +159,8 @@ private constructor(
          * The HTTP client to use in the SDK.
          *
          * Use the one published in `cas-parser-java-client-okhttp` or implement your own.
+         *
+         * This class takes ownership of the client and closes it when closed.
          */
         fun httpClient(httpClient: HttpClient) = apply {
             this.httpClient = PhantomReachableClosingHttpClient(httpClient)
@@ -404,4 +408,18 @@ private constructor(
             )
         }
     }
+
+    /**
+     * Closes these client options, relinquishing any underlying resources.
+     *
+     * This is purposefully not inherited from [AutoCloseable] because the client options are
+     * long-lived and usually should not be synchronously closed via try-with-resources.
+     *
+     * It's also usually not necessary to call this method at all. the default client automatically
+     * releases threads and connections if they remain idle, but if you are writing an application
+     * that needs to aggressively release unused resources, then you may call this method.
+     */
+    fun close() {
+        httpClient.close()
+    }
 }

cas-parser-java-core/src/main/kotlin/com/cas_parser/api/core/PhantomReachableExecutorService.kt

@@ -0,0 +1,58 @@
+package com.cas_parser.api.core
+
+import java.util.concurrent.Callable
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Future
+import java.util.concurrent.TimeUnit
+
+/**
+ * A delegating wrapper around an [ExecutorService] that shuts it down once it's only phantom
+ * reachable.
+ *
+ * This class ensures the [ExecutorService] is shut down even if the user forgets to do it.
+ */
+internal class PhantomReachableExecutorService(private val executorService: ExecutorService) :
+    ExecutorService {
+    init {
+        closeWhenPhantomReachable(this) { executorService.shutdown() }
+    }
+
+    override fun execute(command: Runnable) = executorService.execute(command)
+
+    override fun shutdown() = executorService.shutdown()
+
+    override fun shutdownNow(): MutableList<Runnable> = executorService.shutdownNow()
+
+    override fun isShutdown(): Boolean = executorService.isShutdown
+
+    override fun isTerminated(): Boolean = executorService.isTerminated
+
+    override fun awaitTermination(timeout: Long, unit: TimeUnit): Boolean =
+        executorService.awaitTermination(timeout, unit)
+
+    override fun <T : Any?> submit(task: Callable<T>): Future<T> = executorService.submit(task)
+
+    override fun <T : Any?> submit(task: Runnable, result: T): Future<T> =
+        executorService.submit(task, result)
+
+    override fun submit(task: Runnable): Future<*> = executorService.submit(task)
+
+    override fun <T : Any?> invokeAll(
+        tasks: MutableCollection<out Callable<T>>
+    ): MutableList<Future<T>> = executorService.invokeAll(tasks)
+
+    override fun <T : Any?> invokeAll(
+        tasks: MutableCollection<out Callable<T>>,
+        timeout: Long,
+        unit: TimeUnit,
+    ): MutableList<Future<T>> = executorService.invokeAll(tasks, timeout, unit)
+
+    override fun <T : Any?> invokeAny(tasks: MutableCollection<out Callable<T>>): T =
+        executorService.invokeAny(tasks)
+
+    override fun <T : Any?> invokeAny(
+        tasks: MutableCollection<out Callable<T>>,
+        timeout: Long,
+        unit: TimeUnit,
+    ): T = executorService.invokeAny(tasks, timeout, unit)
+}