Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package com.firefly.kotlin.ext.nio
import kotlinx.coroutines.CancellableContinuation
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Job
import kotlinx.coroutines.suspendCancellableCoroutine
import java.net.SocketAddress
import java.nio.ByteBuffer
import java.nio.channels.*
import java.util.concurrent.TimeUnit
/**
* Performs [AsynchronousFileChannel.lock] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousFileChannel.aLock() = suspendCancellableCoroutine { cont ->
lock(cont, asyncIOHandler())
closeOnCancel(cont)
}
/**
* Performs [AsynchronousFileChannel.lock] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousFileChannel.aLock(
position: Long,
size: Long,
shared: Boolean
) = suspendCancellableCoroutine { cont ->
lock(position, size, shared, cont, asyncIOHandler())
closeOnCancel(cont)
}
/**
* Performs [AsynchronousFileChannel.read] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousFileChannel.aRead(
buf: ByteBuffer,
position: Long
) = suspendCancellableCoroutine { cont ->
read(buf, position, cont, asyncIOHandler())
closeOnCancel(cont)
}
/**
* Performs [AsynchronousFileChannel.write] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousFileChannel.aWrite(
buf: ByteBuffer,
position: Long
) = suspendCancellableCoroutine { cont ->
write(buf, position, cont, asyncIOHandler())
closeOnCancel(cont)
}
/**
* Performs [AsynchronousServerSocketChannel.accept] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousServerSocketChannel.aAccept() = suspendCancellableCoroutine { cont ->
accept(cont, asyncIOHandler())
closeOnCancel(cont)
}
/**
* Performs [AsynchronousSocketChannel.connect] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousSocketChannel.aConnect(
socketAddress: SocketAddress
) = suspendCancellableCoroutine { cont ->
connect(socketAddress, cont, AsyncVoidIOHandler)
closeOnCancel(cont)
}
/**
* Performs [AsynchronousSocketChannel.read] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousSocketChannel.aRead(
buf: ByteBuffer,
timeout: Long = 0L,
timeUnit: TimeUnit = TimeUnit.MILLISECONDS
) = suspendCancellableCoroutine { cont ->
read(buf, timeout, timeUnit, cont, asyncIOHandler())
closeOnCancel(cont)
}
/**
* Performs [AsynchronousSocketChannel.write] without blocking a thread and resumes when asynchronous operation completes.
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* *closes the underlying channel* and immediately resumes with [CancellationException].
*/
suspend fun AsynchronousSocketChannel.aWrite(
buf: ByteBuffer,
timeout: Long = 0L,
timeUnit: TimeUnit = TimeUnit.MILLISECONDS
) = suspendCancellableCoroutine { cont ->
write(buf, timeout, timeUnit, cont, asyncIOHandler())
closeOnCancel(cont)
}
// ---------------- private details ----------------
private fun Channel.closeOnCancel(cont: CancellableContinuation<*>) {
cont.invokeOnCancellation {
try {
close()
} catch (ex: Throwable) {
// Specification says that it is Ok to call it any time, but reality is different,
// so we have just to ignore exception
}
}
}
@Suppress("UNCHECKED_CAST")
private fun asyncIOHandler(): CompletionHandler> =
AsyncIOHandlerAny as CompletionHandler>
private object AsyncIOHandlerAny : CompletionHandler> {
override fun completed(result: Any, cont: CancellableContinuation) {
cont.resumeWith(Result.success(result))
}
override fun failed(ex: Throwable, cont: CancellableContinuation) {
// just return if already cancelled and got an expected exception for that case
if (ex is AsynchronousCloseException && cont.isCancelled) {
return
}
cont.resumeWith(Result.failure(ex))
}
}
private object AsyncVoidIOHandler : CompletionHandler> {
override fun completed(result: Void?, cont: CancellableContinuation) {
cont.resumeWith(Result.success(Unit))
}
override fun failed(ex: Throwable, cont: CancellableContinuation) {
// just return if already cancelled and got an expected exception for that case
if (ex is AsynchronousCloseException && cont.isCancelled) {
return
}
cont.resumeWith(Result.failure(ex))
}
}
