core/com.hexagontk.core

Package-level declarations

Platform information and other useful utilities. Includes basic program settings support at the Platform object (like loading and retrieving system settings).

Provides a logging management capabilities abstracting the application from logging libraries.

The following code block shows the most common use cases for the logging utilities:

Types

ClasspathHandler

object ClasspathHandler : URLStreamHandler

CodedException

class CodedException(val code: Int, message: String = "", cause: Throwable? = null) : RuntimeException

Exception with a numeric code.

MultipleException

class MultipleException(val causes: List<Throwable>, message: String = "") : RuntimeException

Exception with a list of causes. Cause is null as it can't be told which one of the list is the cause.

OsKind

enum OsKind : Enum<OsKind>

Platform

object Platform

Object with utilities to gather information about the running platform.

ResourceNotFoundException

class ResourceNotFoundException(message: String) : IOException

Properties

ALL_INTERFACES

val ALL_INTERFACES: InetAddress

Internet address used to bind services to all local network interfaces.

assertEnabled

val assertEnabled: Boolean

This flag is true when assertions are enabled in the JVM (-ea flag). Assertions are disabled by default in the JVM, but they are enabled (and should be that way) on the tests.

fail

val fail: Nothing

Syntax sugar to throw errors.

GMT_ZONE

val GMT_ZONE: ZoneId

GMT zone ID.

HEXAGONTK_LOGGING_COLOR

const val HEXAGONTK_LOGGING_COLOR: String

HEXAGONTK_LOGGING_LOGGER_NAME

const val HEXAGONTK_LOGGING_LOGGER_NAME: String

logger

val logger: System.Logger

Default logger for when you feel too lazy to declare one.

LOOPBACK_INTERFACE

val LOOPBACK_INTERFACE: InetAddress

Internet address used to bind services to the loop-back interface.

Functions

debug

fun <T> T.debug(prefix: String = ""): T

Use this T to log a message with a prefix using DEBUG level.

fun System.Logger.debug(message: () -> Any?)

Log a message using DEBUG level.

error

fun System.Logger.error(message: () -> Any?)

Log a message using ERROR level.

fun <E : Throwable> System.Logger.error(exception: E?, message: (E?) -> Any? = { "" })

Log a message using ERROR level with associated exception information.

exists

fun URL.exists(): Boolean

fieldsMapOf

fun <T : Any> fieldsMapOf(vararg fields: Pair<KProperty1<T, *>, *>): Map<String, *>

fieldsMapOfNotNull

fun <T : Any> fieldsMapOfNotNull(vararg fields: Pair<KProperty1<T, *>, *>): Map<String, *>

filterNotEmpty

fun <V> Collection<V?>.filterNotEmpty(): Collection<V>

fun <K, V> Map<K, V?>.filterNotEmpty(): Map<K, V>

filterNotEmptyRecursive

fun Collection<*>.filterNotEmptyRecursive(): Collection<*>

fun Map<*, *>.filterNotEmptyRecursive(): Map<*, *>

filterStackTrace

fun Throwable.filterStackTrace(prefix: String): Array<out StackTraceElement>

Return the stack trace array of the frames that starts with the given prefix.

firstVariant

fun URL.firstVariant(vararg suffixes: String): URL

freePort

fun freePort(): Int

Return a random free port (not used by any other local process).

get

inline operator fun <T : Any> Map<*, *>.get(key: KProperty1<*, *>): T?

getBoolean

fun Map<*, *>.getBoolean(key: KProperty1<*, *>): Boolean?

getBooleans

fun Map<*, *>.getBooleans(key: KProperty1<*, *>): Collection<Boolean>?

getBooleansOrEmpty

fun Map<*, *>.getBooleansOrEmpty(key: KProperty1<*, *>): Collection<Boolean>

getDouble

fun Map<*, *>.getDouble(key: KProperty1<*, *>): Double?

getDoubles

fun Map<*, *>.getDoubles(key: KProperty1<*, *>): Collection<Double>?

getDoublesOrEmpty

fun Map<*, *>.getDoublesOrEmpty(key: KProperty1<*, *>): Collection<Double>

getFloat

fun Map<*, *>.getFloat(key: KProperty1<*, *>): Float?

getFloats

fun Map<*, *>.getFloats(key: KProperty1<*, *>): Collection<Float>?

getFloatsOrEmpty

fun Map<*, *>.getFloatsOrEmpty(key: KProperty1<*, *>): Collection<Float>

getInt

fun Map<*, *>.getInt(key: KProperty1<*, *>): Int?

getInts

fun Map<*, *>.getInts(key: KProperty1<*, *>): Collection<Int>?

getIntsOrEmpty

fun Map<*, *>.getIntsOrEmpty(key: KProperty1<*, *>): Collection<Int>

getList

fun Map<*, *>.getList(key: KProperty1<*, *>): Collection<*>?

getListOrEmpty

fun Map<*, *>.getListOrEmpty(key: KProperty1<*, *>): Collection<*>

getLists

fun Map<*, *>.getLists(key: KProperty1<*, *>): Collection<List<*>>?

getListsOrEmpty

fun Map<*, *>.getListsOrEmpty(key: KProperty1<*, *>): Collection<Collection<*>>

getLong

fun Map<*, *>.getLong(key: KProperty1<*, *>): Long?

getLongs

fun Map<*, *>.getLongs(key: KProperty1<*, *>): Collection<Long>?

getLongsOrEmpty

fun Map<*, *>.getLongsOrEmpty(key: KProperty1<*, *>): Collection<Long>

getMap

fun Map<*, *>.getMap(key: KProperty1<*, *>): Map<String, *>?

getMapOrEmpty

fun Map<*, *>.getMapOrEmpty(key: KProperty1<*, *>): Map<String, *>

getMaps

fun Map<*, *>.getMaps(key: KProperty1<*, *>): Collection<Map<String, *>>?

getMapsOrEmpty

fun Map<*, *>.getMapsOrEmpty(key: KProperty1<*, *>): Collection<Map<String, *>>

getOrDefault

inline fun <T : Any> Map<*, *>.getOrDefault(key: KProperty1<*, *>, default: T): T

getPath

inline fun <T : Any> Map<*, *>.getPath(vararg keys: Any): T?

getString

fun Map<*, *>.getString(key: KProperty1<*, *>): String?

getStrings

fun Map<*, *>.getStrings(key: KProperty1<*, *>): Collection<String>?

getStringsOrEmpty

fun Map<*, *>.getStringsOrEmpty(key: KProperty1<*, *>): Collection<String>

inetAddress

fun inetAddress(vararg bytes: Byte): InetAddress

Syntactic sugar to create an Internet address.

info

fun <T> T.info(prefix: String = ""): T

Use this T to log a message with a prefix using INFO level.

fun System.Logger.info(message: () -> Any?)

Log a message using INFO level.

isPortOpened

fun isPortOpened(port: Int): Boolean

Check if a port is already opened.

localized

fun URL.localized(locale: Locale): URL

log

fun <E : Throwable> System.Logger.log(level: System.Logger.Level, exception: E, message: (E) -> Any?)

Log a message, with associated exception information.

loggerOf

fun loggerOf(name: String): System.Logger

fun loggerOf(type: KClass<*>): System.Logger

Logger constructor function.

mapOfNotNull

fun <K : Any> mapOfNotNull(vararg pairs: Pair<K, *>): Map<K, *>

merge

fun merge(maps: Collection<Map<*, *>>): Map<*, *>

fun merge(mapA: Map<*, *>, mapB: Map<*, *>): Map<*, *>

notEmpty

fun <V> notEmpty(value: V?): Boolean

pairs

fun <K, V> Map<K, Collection<V>>.pairs(): Collection<Pair<K, V>>

parseDuration

fun parseDuration(text: String): Duration

Parse a time duration allowing a more relaxed format: with spaces or commas, lowercase characters and not forcing the text to start with 'P', however, the 'T' is still mandatory to separate date and time durations.

parseLocalDate

fun parseLocalDate(text: String): LocalDate

Parse a local date allowing only to specify the year or the year and the month. Missing month and day will be defaulted to january and one respectively.

parsePeriod