trans-gen 0.4.0

Generating trans code from Rust into other languages
Documentation 
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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

package util

import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.charset.StandardCharsets

object StreamUtil {
    @Throws(IOException::class)
    fun readBytes(stream: InputStream, byteCount: Int): ByteArray {
        val bytes = ByteArray(byteCount)
        var offset = 0
        while (offset < bytes.size) {
            val read = stream.read(bytes, offset, bytes.size - offset)
            if (read == -1) {
                break
            }
            offset += read
        }
        if (offset != bytes.size) {
            throw IOException("Unexpected EOF")
        }
        return bytes
    }

    @Throws(IOException::class)
    fun readBoolean(stream: InputStream): Boolean {
        return ByteBuffer.wrap(readBytes(stream, 1)).get().toInt() != 0
    }

    @Throws(IOException::class)
    fun readInt(stream: InputStream): Int {
        return ByteBuffer.wrap(readBytes(stream, Integer.BYTES)).order(ByteOrder.LITTLE_ENDIAN).int
    }

    @Throws(IOException::class)
    fun readLong(stream: InputStream): Long {
        return ByteBuffer.wrap(readBytes(stream, java.lang.Long.BYTES)).order(ByteOrder.LITTLE_ENDIAN).long
    }

    @Throws(IOException::class)
    fun readFloat(stream: InputStream): Float {
        return ByteBuffer.wrap(readBytes(stream, java.lang.Float.BYTES)).order(ByteOrder.LITTLE_ENDIAN).float
    }

    @Throws(IOException::class)
    fun readDouble(stream: InputStream): Double {
        return ByteBuffer.wrap(readBytes(stream, java.lang.Double.BYTES)).order(ByteOrder.LITTLE_ENDIAN).double
    }

    @Throws(IOException::class)
    fun readString(stream: InputStream): String {
        val length = readInt(stream)
        return String(readBytes(stream, length), StandardCharsets.UTF_8)
    }

    @Throws(IOException::class)
    fun writeBytes(stream: OutputStream, bytes: ByteArray) {
        stream.write(bytes)
    }

    @Throws(IOException::class)
    fun writeBoolean(stream: OutputStream, value: Boolean) {
        writeBytes(stream, byteArrayOf((if (value) 1 else 0).toByte()))
    }

    @Throws(IOException::class)
    fun writeInt(stream: OutputStream, value: Int) {
        writeBytes(stream, ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN).putInt(value).array())
    }

    @Throws(IOException::class)
    fun writeLong(stream: OutputStream, value: Long) {
        writeBytes(stream, ByteBuffer.allocate(java.lang.Long.BYTES).order(ByteOrder.LITTLE_ENDIAN).putLong(value).array())
    }

    @Throws(IOException::class)
    fun writeFloat(stream: OutputStream, value: Float) {
        writeBytes(stream, ByteBuffer.allocate(java.lang.Float.BYTES).order(ByteOrder.LITTLE_ENDIAN).putFloat(value).array())
    }

    @Throws(IOException::class)
    fun writeDouble(stream: OutputStream, value: Double) {
        writeBytes(stream, ByteBuffer.allocate(java.lang.Double.BYTES).order(ByteOrder.LITTLE_ENDIAN).putDouble(value).array())
    }

    @Throws(IOException::class)
    fun writeString(stream: OutputStream, value: String) {
        val bytes = value.toByteArray(StandardCharsets.UTF_8)
        writeInt(stream, bytes.size)
        writeBytes(stream, bytes)
    }
}