com.eignex.kencode

Top-level

Start here to find your way around the API. Three entry points cover the common tasks; everything else in the symbol list supports them.

Start with	When you want to
EncodedFormat	Turn a `@Serializable` type into a short string, and back.
PackedFormat	Get the compact `ByteArray` without the text layer.
ByteEncoding	Encode raw bytes with a codec directly — Base62, Base36, Base64, Base85.

val encoded = EncodedFormat.encodeToString(payload)
val decoded = EncodedFormat.decodeFromString<Payload>(encoded)

Configure a format through its builder lambda: swap the codec, add a checksum, or chain PayloadTransforms. On the packed side, annotate Int/Long fields with PackedType and IntPacking to opt into varint or ZigZag.

Types

Alphabet

interface Alphabet

Maps indices to characters (encoding) and characters back to indices (decoding). indexOf returns -1 for characters not in the alphabet.

Base36

object Base36 : BaseRadix

Base36 encoder/decoder using digits and lowercase characters.

Base62

object Base62 : BaseRadix

Base62 encoder/decoder using digits, lowercase, then uppercase characters.

Base64

open class Base64(val alphabet: CharArray) : ByteEncoding

RFC 4648–compatible Base64 encoder/decoder.

Base64Url

object Base64Url : Base64

URL- and filename-safe variant of Base64 using the BASE_64_URL alphabet.

Base85

open class Base85(alphabet: CharArray) : ByteEncoding

Generic Base85 encoder/decoder supporting both ASCII85 and ZeroMQ Z85. 4 input bytes -> 5 output chars. Allows final partial group (1–3 bytes -> 2–4 chars).

BaseRadix

open class BaseRadix(alphabet: Alphabet, val blockSize: Int = 32) : ByteEncoding

Generic base-N encoder/decoder for binary data using arbitrary alphabets and block processing.

ByteEncoding

interface ByteEncoding

Abstraction for bidirectional byte–text encodings (e.g., Base62, Base64).

CharAlphabet

class CharAlphabet(chars: String) : Alphabet

Alphabet backed by an explicit string of characters.

Checksum

interface Checksum

Generic checksum interface that produces a fixed number of bytes.

CompactZeros

object CompactZeros : PayloadTransform

Strips leading zero bytes before encoding and restores them on decode.

Crc16

open class Crc16(poly: Int = 4129, init: Int = 65535, refin: Boolean = true, refout: Boolean = true, xorOut: Int = 65535) : Checksum

CRC-16/X-25 implementation.

Crc32

open class Crc32(poly: Int = 79764919, init: Int = 0xFFFFFFFF.toInt(), refin: Boolean = true, refout: Boolean = true, xorOut: Int = 0xFFFFFFFF.toInt()) : Checksum

CRC-32/ISO-HDLC implementation.

Crc8

open class Crc8(poly: Int = 7, init: Int = 0, refin: Boolean = false, refout: Boolean = false, xorOut: Int = 0) : Checksum

CRC-8/SMBUS implementation.

EncodedConfiguration

data class EncodedConfiguration(val codec: ByteEncoding = Base62, val transform: PayloadTransform? = null, val binaryFormat: BinaryFormat = PackedFormat.Default)

Holds the configuration for an EncodedFormat instance.

EncodedFormat

open class EncodedFormat(val configuration: EncodedConfiguration) : StringFormat

Text StringFormat that produces short, predictable string tokens by composing:

EncodedFormatBuilder

class EncodedFormatBuilder

Builder for configuring EncodedFormat instances.

IntPacking

enum IntPacking : Enum<IntPacking>

Integer encoding strategy for Int and Long fields in PackedFormat.

PackedConfiguration

data class PackedConfiguration(val defaultEncoding: IntPacking = IntPacking.DEFAULT)

Holds the configuration for a PackedFormat instance.

PackedDecoder

class PackedDecoder : Decoder, CompositeDecoder

Binary decoder for the PackedFormat wire format. Reads merged class bitmask headers and per-field data produced by PackedEncoder.

PackedEncoder

class PackedEncoder : Encoder, CompositeEncoder

Binary encoder for the PackedFormat wire format. Accumulates merged class bitmask headers and per-field data, producing output consumable by PackedDecoder.

PackedFormat

open class PackedFormat(val configuration: PackedConfiguration = PackedConfiguration(), val serializersModule: SerializersModule = EmptySerializersModule()) : BinaryFormat

Compact BinaryFormat optimized for small, flat Kotlin data classes.

PackedFormatBuilder

class PackedFormatBuilder

Builder for configuring PackedFormat instances.

PackedType

@SerialInfo

@Target(allowedTargets = [AnnotationTarget.PROPERTY])

annotation class PackedType(val type: IntPacking)

Overrides the integer encoding strategy for an Int or Long field in PackedFormat. Falls back to kotlinx.serialization.protobuf.ProtoType if present, then PackedConfiguration.defaultEncoding.

PayloadTransform

interface PayloadTransform

Transforms a binary payload before base-encoding and after base-decoding.

UnicodeRangeAlphabet

class UnicodeRangeAlphabet(start: Int = 32, val size: Int = 0xD800 - 0x0020) : Alphabet

Alphabet backed by a contiguous Unicode range starting at start. Defaults to U+0020 – U+D7FF (55,264 characters), the largest BMP range that avoids surrogate code points.