Utilities/mtctx.utilities.datasizes

Package-level declarations

Types

object BinaryDataSize : DataSizeInBytes

Provides binary (base-1024) data size constants, following IEC standards (e.g., KiB, MiB). This is typically used for memory-related calculations, such as RAM or certain software contexts.

DataSizeInBytes

interface DataSizeInBytes

Defines standard data size units in bytes, providing constants for common storage measurements. Implementations of this interface specify whether the units follow binary (base-1024) or decimal (base-1000) conventions. These constants are useful for calculations involving file sizes, memory, or network data.

DecimalDataSize

object DecimalDataSize : DataSizeInBytes

Provides decimal (base-1000) data size constants, following SI standards (e.g., KB, MB). This is typically used for file systems, network speeds, and other contexts where base-1000 units are standard.

NumberConversionIsUnsafeAndCouldCauseBufferOverflow

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.LOCAL_VARIABLE])

annotation class NumberConversionIsUnsafeAndCouldCauseBufferOverflow

Marks number conversion operations that may be unsafe due to potential overflow.

Properties

val Double.eb: Double

Converts a Double to exabytes (EB, 1000^6 bytes).

val Int.eb: Long

Converts an Int to exabytes (EB, 1000^6 bytes).

val Long.eb: Long

Converts a Long to exabytes (EB, 1000^6 bytes).

val Double.ebSafe: BigDecimal

Safely converts a Double to exabytes (EB, 1000^6 bytes) using BigDecimal.

val Int.ebSafe: BigInteger

Safely converts an Int to exabytes (EB, 1000^6 bytes) using BigInteger.

val Long.ebSafe: BigInteger

Safely converts a Long to exabytes (EB, 1000^6 bytes) using BigInteger.

val Double.eib: Double

Converts a Double to exbibytes (EiB, 1024^6 bytes).

val Int.eib: Long

Converts an Int to exbibytes (EiB, 1024^6 bytes).

val Long.eib: Long

Converts a Long to exbibytes (EiB, 1024^6 bytes).

val Double.eibSafe: BigDecimal

Safely converts a Double to exbibytes (EiB, 1024^6 bytes) using BigDecimal.

val Int.eibSafe: BigInteger

Safely converts an Int to exbibytes (EiB, 1024^6 bytes) using BigInteger.

val Long.eibSafe: BigInteger

Safely converts a Long to exbibytes (EiB, 1024^6 bytes) using BigInteger.

val Double.gb: Double

Converts a Double to gigabytes (GB, 1000^3 bytes).

val Int.gb: Long

Converts an Int to gigabytes (GB, 1000^3 bytes).

val Long.gb: Long

Converts a Long to gigabytes (GB, 1000^3 bytes).

val Double.gib: Double

Converts a Double to gibibytes (GiB, 1024^3 bytes).

val Int.gib: Long

Converts an Int to gibibytes (GiB, 1024^3 bytes).

val Long.gib: Long

Converts a Long to gibibytes (GiB, 1024^3 bytes).

val Double.kb: Double

Converts a Double to kilobytes (KB, 1000 bytes).

val Int.kb: Long

Converts an Int to kilobytes (KB, 1000 bytes).

val Long.kb: Long

Converts a Long to kilobytes (KB, 1000 bytes).

val Double.kib: Double

Converts a Double to kibibytes (KiB, 1024 bytes).

val Int.kib: Long

Converts an Int to kibibytes (KiB, 1024 bytes).

val Long.kib: Long

Converts a Long to kibibytes (KiB, 1024 bytes).

val Double.mb: Double

Converts a Double to megabytes (MB, 1000^2 bytes).

val Int.mb: Long

Converts an Int to megabytes (MB, 1000^2 bytes).

val Long.mb: Long

Converts a Long to megabytes (MB, 1000^2 bytes).

val Double.mib: Double

Converts a Double to mebibytes (MiB, 1024^2 bytes).

val Int.mib: Long

Converts an Int to mebibytes (MiB, 1024^2 bytes).

val Long.mib: Long

Converts a Long to mebibytes (MiB, 1024^2 bytes).

val Double.pb: Double

Converts a Double to petabytes (PB, 1000^5 bytes).

val Int.pb: Long

Converts an Int to petabytes (PB, 1000^5 bytes).

val Long.pb: Long

Converts a Long to petabytes (PB, 1000^5 bytes).

val Double.pbSafe: BigDecimal

Safely converts a Double to petabytes (PB, 1000^5 bytes) using BigDecimal.

val Int.pbSafe: BigInteger

Safely converts an Int to petabytes (PB, 1000^5 bytes) using BigInteger.

val Long.pbSafe: BigInteger

Safely converts a Long to petabytes (PB, 1000^5 bytes) using BigInteger.

val Double.pib: Double

Converts a Double to pebibytes (PiB, 1024^5 bytes).

val Int.pib: Long

Converts an Int to pebibytes (PiB, 1024^5 bytes).

val Long.pib: Long

Converts a Long to pebibytes (PiB, 1024^5 bytes).

val Double.pibSafe: BigDecimal

Safely converts a Double to pebibytes (PiB, 1024^5 bytes) using BigDecimal.

val Int.pibSafe: BigInteger

Safely converts an Int to pebibytes (PiB, 1024^5 bytes) using BigInteger.

val Long.pibSafe: BigInteger

Safely converts a Long to pebibytes (PiB, 1024^5 bytes) using BigInteger.

val Double.tb: Double

Converts a Double to terabytes (TB, 1000^4 bytes).

val Int.tb: Long

Converts an Int to terabytes (TB, 1000^4 bytes).

val Long.tb: Long

Converts a Long to terabytes (TB, 1000^4 bytes).

val Double.tib: Double

Converts a Double to tebibytes (TiB, 1024^4 bytes).

val Int.tib: Long

Converts an Int to tebibytes (TiB, 1024^4 bytes).

val Long.tib: Long

Converts a Long to tebibytes (TiB, 1024^4 bytes).