core/nl.adaptivity.xmlutil.core.impl.multiplatform

Package-level declarations

Types

AutoCloseable

actual interface AutoCloseable

expect interface AutoCloseable

actual interface AutoCloseable

actual typealias AutoCloseable = java.lang.AutoCloseable

Closeable

actual interface Closeable : AutoCloseable

expect interface Closeable : AutoCloseable

actual interface Closeable : AutoCloseable

actual typealias Closeable = java.io.Closeable

FileInputStream

class FileInputStream(val filePtr: FilePtr) : InputStream

Implementation of a FileInputStream based upon native file access.

FileMode

interface FileMode

FileNotFoundException

expect open class FileNotFoundException : IOException

actual open class FileNotFoundException : IOException

actual typealias FileNotFoundException = java.io.FileNotFoundException

actual open class FileNotFoundException : IOException

FileOutputStream

class FileOutputStream(val filePtr: FilePtr) : NativeOutputStream

FilePtr

value class FilePtr(val value: <Error class: unknown class><<Error class: unknown class>>)

InputStream

expect abstract class InputStream : Closeable

actual abstract class InputStream : Closeable

actual typealias InputStream = java.io.InputStream

actual abstract class InputStream : Closeable

InputStreamReader

class InputStreamReader(val inputStream: InputStream) : Reader

An implementation of a reader that reads (UTF-8 only) input streams.

IOException

expect open class IOException : Exception

actual open class IOException : Exception

actual typealias IOException = java.io.IOException

actual open class IOException : Exception

Language

actual annotation class Language(val value: String, val prefix: String, val suffix: String)

expect annotation class Language(val value: String, val prefix: String = "", val suffix: String = "")

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.FIELD, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.ANNOTATION_CLASS])

actual annotation class Language(val value: String, val prefix: String, val suffix: String)

actual typealias Language = org.intellij.lang.annotations.Language

Locale

typealias ~~Locale~~ = java.util.Locale

MpJvmDefaultWithCompatibility

@Target(allowedTargets = [AnnotationTarget.CLASS])

actual annotation class MpJvmDefaultWithCompatibility

@Target(allowedTargets = [AnnotationTarget.CLASS])

expect annotation class MpJvmDefaultWithCompatibility

@Target(allowedTargets = [AnnotationTarget.CLASS])

actual annotation class MpJvmDefaultWithCompatibility

actual typealias MpJvmDefaultWithCompatibility = JvmDefaultWithCompatibility

MpJvmDefaultWithoutCompatibility

@Target(allowedTargets = [AnnotationTarget.CLASS])

actual annotation class MpJvmDefaultWithoutCompatibility

@Target(allowedTargets = [AnnotationTarget.CLASS])

expect annotation class MpJvmDefaultWithoutCompatibility

@Target(allowedTargets = [AnnotationTarget.CLASS])

actual annotation class MpJvmDefaultWithoutCompatibility

actual typealias MpJvmDefaultWithoutCompatibility = JvmDefaultWithoutCompatibility

NativeOutputStream

abstract class NativeOutputStream : OutputStream

OutputStream

expect abstract class OutputStream : Closeable

actual abstract class OutputStream : Closeable

actual typealias OutputStream = java.io.OutputStream

actual abstract class OutputStream : Closeable

OutputStreamWriter

class OutputStreamWriter(val outStream: NativeOutputStream) : Writer, Closeable

Reader

actual abstract class Reader

expect abstract class Reader

actual abstract class Reader

actual typealias Reader = java.io.Reader

SizeT

value class SizeT(val value: <Error class: unknown class>)

Wrapper type to stand in for size_t as that type has inconsistent sizes in different architectures.

StringReader

actual open class StringReader : Reader

expect open class StringReader : Reader

actual open class StringReader : Reader

actual typealias StringReader = java.io.StringReader

StringWriter

actual open class StringWriter : Writer

expect open class StringWriter : Writer

actual open class StringWriter : Writer

Throws

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR])

expect annotation class Throws(val exceptionClasses: KClass<out Throwable>)

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR])

actual annotation class Throws(val exceptionClasses: KClass<out Throwable>)

actual typealias Throws = kotlin.jvm.Throws

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR])

actual annotation class Throws(val exceptionClasses: KClass<out Throwable>)

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR])

actual annotation class Throws(val exceptionClasses: KClass<out Throwable>)

URI

typealias URI = java.net.URI

Writer

actual abstract class Writer : Appendable

expect abstract class Writer : Appendable

actual abstract class Writer : Appendable

Properties

maybeAnnotations

actual val KClass<*>.maybeAnnotations: List<Annotation>

expect val KClass<*>.maybeAnnotations: List<Annotation>

actual val KClass<*>.maybeAnnotations: List<Annotation>

name

expect val KClass<*>.name: String

actual val KClass<*>.name: String

Functions

assert

expect fun assert(value: Boolean)

expect fun assert(value: Boolean, lazyMessage: () -> String)

actual fun assert(value: Boolean)

actual fun assert(value: Boolean, lazyMessage: () -> String)

actual fun assert(value: Boolean)

actual fun assert(value: Boolean, lazyMessage: () -> String)

actual fun assert(value: Boolean)

actual fun assert(value: Boolean, lazyMessage: () -> String)

actual fun assert(value: Boolean)

actual fun assert(value: Boolean, lazyMessage: () -> String)

computeIfAbsent

actual inline fun <K, V> MutableMap<K, V>.computeIfAbsent(key: K, defaultValue: () -> V): V

expect inline fun <K, V> MutableMap<K, V>.computeIfAbsent(key: K, crossinline defaultValue: () -> V): V

actual inline fun <K, V> MutableMap<K, V>.computeIfAbsent(key: K, crossinline defaultValue: () -> V): V

sizeT

fun sizeT(i: Int): SizeT

fun sizeT(l: Long): SizeT

fun sizeT(i: UInt): SizeT

fun sizeT(l: ULong): SizeT

use

actual inline fun <T : Closeable?, R> T.use(block: (T) -> R): R

expect inline fun <T : Closeable?, R> T.use(block: (T) -> R): R

actual inline fun <T : Closeable?, R> T.use(block: (T) -> R): R

inline fun <T : Closeable, R> T.use(block: (T) -> R): R