package Base64
import Bitwise
import StringUtils
import ByteBuffer
import ChunkedString
import Execute
import ErrorHandling
/* Base64 package provides encoding and decoding functions for the common base64 format
that allows serializing and deserializing of any data by writing integers into the Encoder
and reading integers from the Decoder. You'll have to implement writing/reading functions yourself.
Encode Data using a builder pattern:
> let encoder = new Base64Encoder()
> encoder.writeByte(25)
> encoder.writeInt(100500)
> let data = encoder.intoData() // the encoder is consumed, no need to destroy it
Decode Data using a builder pattern:
> let decoder = new Base64Decoder()
> while data.hasChunk()
> decoder.append(data.readChunk())
> let bytes = decoder.intoData() // the decoder is consumed, no need to destroy it
> let byte = bytes.readByte()
> let number = bytes.readInt()
This package also provides convenient methods for ChunkedStrings and ByteBuffers.
Encode Data:
> let data = bytes.encodeBase64() // `data` is of type `ChunkedString`, `bytes` is of type `ByteBuffer`
Decode Data:
> let bytes = data.decodeBase64() // `data` is of type `ChunkedString`, `bytes` is of type `ByteBuffer`
*/
/**
Specifies how many characters to encode per a single `execute()` call.
This value has been tuned to work under all optimization settings and
with stacktraces included.
**/
@configurable public constant ENCODES_PER_ROUND = 1000
/**
Specifies how many chunks to decode per a single `execute()` call.
This value has been tuned to work under all optimization settings and
with stacktraces included.
**/
@configurable public constant DECODES_PER_ROUND = 25
// RFC 4648 compliant Base64 charmap.
constant CHARMAP = [
"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P",
"Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f",
"g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v",
"w","x","y","z","0","1","2","3","4","5","6","7","8","9","+","/"
]
// RFC 4648 compliant Base64 reverse charmap.
constant REVERSE_CHARMAP = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
public class Base64Encoder
private ChunkedString chunkedString
// We append only one char each time, and strings in WC3 get fully copied on each concatenation.
// To optimize it and lower the times of copying quite big chunks, append by smaller chunks.
// These chunks are stored in the `stringBuffer` before appended.
private var stringBuffer = ""
private var chars = 0
private static constant MAX_CHARS = 32
private var buffer = 0
private var bytes = 0
private static constant MAX_BYTES = 3
construct()
this.chunkedString = new ChunkedString()
construct(int maxChunkLength)
this.chunkedString = new ChunkedString(maxChunkLength)
ondestroy
if chunkedString != null // The string is null after calling `intoData()`.
destroy chunkedString
// We're not using `executeWhile()` here to avoid additional overhead in this tight loop.
private function writeData(ByteBuffer data)
execute() ->
var i = 0
while data.hasByte() and i < ENCODES_PER_ROUND
writeByteUnsafe(data.readByte())
i++
if data.hasByte()
writeData(data)
private function flushStringBuffer()
chunkedString.append(stringBuffer)
stringBuffer = ""
chars = 0
private function append(string char)
stringBuffer += char
chars++
if chars == MAX_CHARS
flushStringBuffer()
private function encode(int byte, int count)
var remaining = byte
for i = 0 to count
let c = remaining.bitAnd(compiletime("11111100 00000000 00000000".fromBitString())).shiftr(18)
append(CHARMAP[c])
remaining = remaining.shiftl(6)
/** Writes an unsigned byte to be serialized into Base64.
You must be sure that the provided integer is in the range [0, 255]. */
private function writeByteUnsafe(int n)
buffer = buffer.shiftl(8) + n
bytes++
if bytes == MAX_BYTES
encode(buffer, 3)
bytes = 0
/** Writes an unsigned short to be serialized into Base64.
You must be sure that the provided integer is in the range [0, 65535]. */
private function writeShortUnsafe(int n)
writeByteUnsafe(n.bitAnd(compiletime("11111111".fromBitString())))
writeByteUnsafe(n.shiftr(8))
/** Writes an unsigned byte to be serialized into Base64. */
function writeByte(int n)
writeByteUnsafe(n.bitAnd(compiletime("11111111".fromBitString())))
/** Writes an unsigned short to be serialized into Base64. */
function writeShort(int n)
writeShortUnsafe(n.bitAnd(compiletime("11111111 11111111".fromBitString())))
/** Writes a signed integer to be serialized into Base64. */
function writeInt(int n)
writeShortUnsafe(n.bitAnd(compiletime("11111111 11111111".fromBitString())))
writeShortUnsafe(n.shiftr(16))
/** Writes all bytes from the buffer to be serialized into Base64. */
function write(ByteBuffer data)
writeData(data)
data.resetRead()
/** Writes all bytes from the buffer to be serialized into Base64 and destroys the buffer. */
function consume(ByteBuffer data)
writeData(data)
destroy data
/** Consumes this encoder and returns the encoded data as a ChunkedString. */
function intoData() returns ChunkedString
if bytes != 0
encode(buffer.shiftl(8 * (3 - bytes)), bytes)
append("=")
if bytes == 1
append("=")
flushStringBuffer()
let tmp = chunkedString
chunkedString = null
destroy this
return tmp
public class Base64Decoder
private var byteBuffer = new ByteBuffer()
private var buffer = ""
private var bufferLength = 0
private static constant MAX_CHARS = 4
private var lastDecoded = ""
ondestroy
if byteBuffer != null // The buffer is null after calling `intoData()`.
destroy byteBuffer
// We're not using `executeWhile()` here to avoid additional overhead in this tight loop.
private function appendData(ChunkedString data)
execute() ->
var i = 0
while data.hasChunk() and i < DECODES_PER_ROUND
append(data.readChunk())
i++
if data.hasChunk()
appendData(data)
/** Appends a part of the Base64-encoded data. */
function append(string data)
let len = data.length()
if bufferLength + len < MAX_CHARS
buffer += data
bufferLength += len
return
var i = MAX_CHARS - bufferLength
writeBytes(buffer + data.substring(0, i))
while i + MAX_CHARS <= len
writeBytes(data.substring(i, i + MAX_CHARS))
i += MAX_CHARS
buffer = data.substring(i)
bufferLength = len - i
/** Appends a part of the Base64-encoded data. */
function append(ChunkedString data)
appendData(data)
data.resetRead()
/** Appends a part of the Base64-encoded data and destroys it. */
function consume(ChunkedString data)
appendData(data)
destroy data
@inline private static function decode(string char) returns int
return REVERSE_CHARMAP[char.toChar().toInt()]
private static constant DECODE_MASK = compiletime("11111111 11111111 11111111".fromBitString())
private function writeBytes(string chars)
lastDecoded = chars
var data = decode(chars.charAt(0)).shiftl(18) + decode(chars.charAt(1)).shiftl(12) + decode(chars.charAt(2)).shiftl(6) + decode(chars.charAt(3))
byteBuffer.writeByte(data.bitAnd(DECODE_MASK).shiftr(16))
data = data.shiftl(8)
byteBuffer.writeByte(data.bitAnd(DECODE_MASK).shiftr(16))
data = data.shiftl(8)
byteBuffer.writeByte(data.bitAnd(DECODE_MASK).shiftr(16))
/** Consumes this decoder and returns the decoded data as a ByteBuffer. **/
function intoData() returns ByteBuffer
if bufferLength > 0
error("Base64 ERROR: The Base-64 encoded data should have length divisible by 4.")
byteBuffer.truncate(byteBuffer.size() - lastDecoded.countOccurences("="))
let tmp = byteBuffer
byteBuffer = null
destroy this
return tmp
/** Encodes the bytes in this buffer to a string according to the Base64 format. */
public function ByteBuffer.encodeBase64() returns ChunkedString
return new Base64Encoder()..consume(this).intoData()
/** Decodes the bytes encoded into this string according to the Base64 format. */
public function ChunkedString.decodeBase64() returns ByteBuffer
return new Base64Decoder()..consume(this).intoData()
/** Decodes the bytes encoded into this string according to the Base64 format. */
public function string.decodeBase64() returns ByteBuffer
return new Base64Decoder()..append(this).intoData()