diff --git a/doc/ru/scripting/modules/core_bit_converter.md b/doc/ru/scripting/modules/core_bit_converter.md index f9930560..44b915c7 100644 --- a/doc/ru/scripting/modules/core_bit_converter.md +++ b/doc/ru/scripting/modules/core_bit_converter.md @@ -1,93 +1,98 @@ # Модуль core:bit_converter +## Доступные порядки байтов +**LE (Little-Endian)** +**BE (Big-Endian)** +По умолчанию используется **LE** + ## Конвертация значений в байты и обратно ```lua -function bit_converter.string_to_bytes(string: str) -> table +function bit_converter.string_to_bytes(str: string) -> table ``` Конвертирует строку в байты ```lua -function bit_converter.bool_to_byte(boolean: bool) -> integer +function bit_converter.bool_to_byte(bool: boolean) -> integer ``` Конвертирует логический булев в байт ```lua -function bit_converter.single_to_bytes(number: single) -> table +function bit_converter.float32_to_bytes(float: number, [опционально] order: string) -> table ``` Конвертирует плавающее значение одинарной точности в байты ```lua -function bit_converter.double_to_bytes(number: double) -> table +function bit_converter.float64_to_bytes(float: number, [опционально] order: string) -> table ``` Конвертирует плавающее значение двойной точности в байты ```lua -function bit_converter.uint16_to_bytes(integer: int) -> table +function bit_converter.uint16_to_bytes(int: integer, [опционально] order: string) -> table ``` Конвертирует беззнаковое 2-х байтовое целое число в байты ```lua -function bit_converter.uint32_to_bytes(integer: int) -> table +function bit_converter.uint32_to_bytes(int: integer, [опционально] order: string) -> table ``` Конвертирует беззнаковое 4-х байтовое целое число в байты ```lua -function bit_converter.int16_to_bytes(integer: int) -> table +function bit_converter.sint16_to_bytes(int: integer, [опционально] order: string) -> table ``` Конвертирует знаковое 2-х байтовое целое число в байты ```lua -function bit_converter.int32_to_bytes(integer: int) -> table +function bit_converter.sint32_to_bytes(int: integer, [опционально] order: string) -> table ``` Конвертирует знаковое 4-х байтовое целое число в байты ```lua -function bit_converter.int64_to_bytes(integer: int) -> table +function bit_converter.int64_to_bytes(int: integer, [опционально] order: string) -> table ``` Конвертирует знаковое 8-и байтовое целое число в байты ```lua -function bit_converter.bytes_to_string(table: bytes) -> string +function bit_converter.bytes_to_string(bytes: table) -> string ``` Конвертирует массив байтов в строку ```lua -function bit_converter.byte_to_bool(integer: byte) -> boolean +function bit_converter.byte_to_bool(byte: integer) -> boolean ``` Конвертирует байт в логическое булевое значение ```lua -function bit_converter.bytes_to_single(table: bytes) -> number№ +function bit_converter.bytes_to_float32(bytes: table|Bytearray, [опционально] order: string) -> number ``` Конвертирует массив байтов в плавающее число одинарной точности ```lua -function bit_converter.bytes_to_double(table: bytes) -> number +function bit_converter.bytes_to_float64(bytes: table|Bytearray, [опционально] order: string) -> number ``` Конвертирует массив байтов в плавающее число двойной точности ```lua -function bit_converter.bytes_to_uint16(table: bytes) -> integer +function bit_converter.bytes_to_uint16(bytes: table|Bytearray, [опционально] order: string) -> integer ``` Конвертирует массив байтов в 2-х байтовое беззнаковое число ```lua -function bit_converter.bytes_to_uint32(table: bytes) -> integer +function bit_converter.bytes_to_uint32(bytes: table|Bytearray, [опционально] order: string) -> integer ``` Конвертирует массив байтов в 4-х байтовое беззнаковое число ```lua -function bit_converter.bytes_to_int16(table: bytes) -> integer +function bit_converter.bytes_to_sint16(bytes: table|Bytearray, [опционально] order: string) -> integer ``` Конвертирует массив байтов в 2-х байтовое знаковое число ```lua -function bit_converter.bytes_to_int32(table: bytes) -> integer +function bit_converter.bytes_to_sint32(bytes: table|Bytearray, [опционально] order: string) -> integer ``` Конвертирует массив байтов в 4-х байтовое знаковое число ```lua -function bit_converter.bytes_to_int64(table: bytes) -> integer +function bit_converter.bytes_to_int64(bytes: table|Bytearray, [опционально] order: string) -> integer ``` Конвертирует массив байтов в 8-х байтовое знаковое число diff --git a/doc/ru/scripting/modules/core_data_buffer.md b/doc/ru/scripting/modules/core_data_buffer.md index 60c36193..09b682b9 100644 --- a/doc/ru/scripting/modules/core_data_buffer.md +++ b/doc/ru/scripting/modules/core_data_buffer.md @@ -4,67 +4,78 @@ ### Хранит в себе массив байтов и позволяет легко получать или добавлять разные значения ```lua -function data_buffer(bytes) +function data_buffer( + [опционально] bytes: table, + [опционально] order: string, + [опционально] useBytearray: boolean +) ``` -Создаёт новый экземпляр data_buffer (параметр bytes необязательный) +Создаёт новый экземпляр **data_buffer**. +Если **useBytearray** равен **true**, то байты буффера будут хранится ввиде **Bytearray**. Это может снизить производительность, но также и уменьшить размер буффера в памяти ```lua -function data_buffer:put_byte(integer: byte) +function data_buffer:set_order(order: string) +``` +Задаёт порядок байтов для чисел. +Должен равняться одному из перечисленных в [**bit_converter**](core_bit_converter.md) + +```lua +function data_buffer:put_byte(byte: integer) ``` Записывает байт в буффер ```lua -function data_buffer:put_bytes(table: bytes) +function data_buffer:put_bytes(bytes: table|Bytearray) ``` Записывает байты в буффер ```lua -function data_buffer:put_string(string: str) +function data_buffer:put_string(str: string) ``` Конвертирует строку в байты и записывает их в буффер ```lua -function data_buffer:put_bool(boolean: bool) +function data_buffer:put_bool(bool: boolean) ``` Конвертирует булевое значение в байт и записывает его в буффер ```lua -function data_buffer:put_single(number: single) +function data_buffer:put_float32(float: number) ``` Конвертирует плавающее число одинарной точности в байты и записывает их в буффер ```lua -function data_buffer:put_double(number: double) +function data_buffer:put_float64(float: number) ``` Конвертирует плавающее число двойной точности в байты и записывает их в буффер ```lua -function data_buffer:put_uint16(integer: int) +function data_buffer:put_uint16(int: integer) ``` Конвертирует беззнаковое 2-х байтовое число в байты и записывает их в буффер ```lua -function data_buffer:put_uint32(integer: int) +function data_buffer:put_uint32(int: integer) ``` Конвертирует беззнаковое 4-х байтовое число в байты и записывает их в буффер ```lua -function data_buffer:put_int16(integer: int) +function data_buffer:put_sint16(int: integer) ``` Конвертирует знаковое 2-х байтовое число в байты и записывает их в буффер ```lua -function data_buffer:put_int32(integer: int) +function data_buffer:put_sint32(int: integer) ``` Конвертирует знаковое 4-х байтовое число в байты и записывает их в буффер ```lua -function data_buffer:put_int64(integer: int) +function data_buffer:put_int64(int: integer) ``` Конвертирует знаковое 8-и байтовое число в байты и записывает их в буффер ```lua -function data_buffer:put_number(number: num) +function data_buffer:put_number(num: number) ``` Конвертирует любое число в байты и записывает их в буффер; @@ -73,10 +84,10 @@ function data_buffer:put_number(number: num) zero = 0 uint16 = 1 uint32 = 2 -int16 = 3 -int32 = 4 int64 = 5 -double = 6 +float64 = 6 +sint16 = 7 +sint32 = 8 ``` ```lua @@ -85,9 +96,9 @@ function data_buffer:get_byte() -> integer Возвращает следующий байт из буффера ```lua -function data_buffer:get_bytes(n) -> table +function data_buffer:get_bytes(n) -> table|Bytearray ``` -Возвращает n следующих байтов, если n равен nil или не указан, то возвращается массив всех байтов +Возвращает **n** следующих байтов, если **n** равен **nil** или не указан, то возвращается массив всех байтов ```lua function data_buffer:get_string() -> string @@ -100,12 +111,12 @@ function data_buffer:get_bool() -> boolean Читает следующий логический булев из буффера ```lua -function data_buffer:get_single() -> number +function data_buffer:get_float32() -> number ``` Читает следующее плавающее число одинарной точности из буффера ```lua -function data_buffer:get_double() -> number +function data_buffer:get_float64() -> number ``` Читает следующее плавающее число двойной точности из буффера @@ -120,12 +131,12 @@ function data_buffer:get_uint32() -> integer Читает следующее 4-х байтовое беззнаковое целое число из буффера ```lua -function data_buffer:get_int16() -> integer +function data_buffer:get_sint16() -> integer ``` Читает следующее 2-х байтовое знаковое целое число из буффера ```lua -function data_buffer:get_int32() -> integer +function data_buffer:get_sint32() -> integer ``` Читает следующее 4-х байтовое знаковое целое число из буффера diff --git a/res/modules/bit_converter.lua b/res/modules/bit_converter.lua index 86afa334..71161eff 100644 --- a/res/modules/bit_converter.lua +++ b/res/modules/bit_converter.lua @@ -12,17 +12,57 @@ local MIN_INT32 = -2147483648 local MAX_INT64 = 9223372036854775807 local MIN_INT64 = -9223372036854775808 -local function intToByte(num) +local function maskHighBytes(num) return bit.band(num, 0xFF) end -local function reverse(tab) - for i = 1, math.floor(#tab, 2), 1 do - tab[i], tab[#tab-i+1] = tab[#tab-i+1], tab[i] - end - return tab +local function reverse(tbl) + for i=1, math.floor(#tbl / 2) do + local tmp = tbl[i] + tbl[i] = tbl[#tbl - i + 1] + tbl[#tbl - i + 1] = tmp + end + return tbl end +local orders = { "LE", "BE" } + +local fromLEConvertors = +{ + LE = function(bytes) return bytes end, + BE = function(bytes) return reverse(bytes) end +} + +local toLEConvertors = +{ + LE = function(bytes) return bytes end, + BE = function(bytes) return reverse(bytes) end +} + +bit_converter.default_order = "LE" + +local function fromLE(bytes, orderTo) + if orderTo then + bit_converter.validate_order(orderTo) + return fromLEConvertors[orderTo](bytes) + else return bytes end +end + +local function toLE(bytes, orderFrom) + if orderFrom then + bit_converter.validate_order(orderFrom) + return toLEConvertors[orderFrom](bytes) + else return bytes end +end + +function bit_converter.validate_order(order) + if not bit_converter.is_valid_order(order) then + error("invalid order: "..order) + end +end + +function bit_converter.is_valid_order(order) return table.has(orders, order) end + function bit_converter.string_to_bytes(str) local bytes = { } @@ -83,19 +123,12 @@ local function floatOrDoubleToBytes(val, opt) bytes[#bytes + 1] = math.floor(sign * 128 + val) % (2 ^ 8) val = math.floor((sign * 128 + val) / (2 ^ 8)) - if not endianness then - reverse(bytes) - end return bytes end local function bytesToFloatOrDouble(bytes, opt) local n = (opt == 'd') and 8 or 4 - if not endianness then - reverse(bytes) - end - local sign = 1 local mantissa = bytes[n - 1] % ((opt == 'd') and 16 or 128) for i = n - 2, 1, -1 do @@ -117,80 +150,128 @@ end -- -function bit_converter.single_to_bytes(float) - return floatOrDoubleToBytes(float, 'f') +function bit_converter.float32_to_bytes(float, order) + return fromLE(floatOrDoubleToBytes(float, 'f'), order) end -function bit_converter.double_to_bytes(double) - return floatOrDoubleToBytes(double, 'd') +function bit_converter.float64_to_bytes(float, order) + return fromLE(floatOrDoubleToBytes(float, 'd'), order) end -function bit_converter.uint32_to_bytes(int) +function bit_converter.single_to_bytes(float, order) + on_deprecated_call("bit_converter.float_to_bytes", "bit_converter.float32_to_bytes") + return bit_converter.float32_to_bytes(bytes, order) +end + +function bit_converter.double_to_bytes(double, order) + on_deprecated_call("bit_converter.double_to_bytes", "bit_converter.float64_to_bytes") + return bit_converter.float64_to_bytes(bytes, order) +end + +local function uint32ToBytes(int, order) + return fromLE({ + maskHighBytes(bit.rshift(int, 24)), + maskHighBytes(bit.rshift(int, 16)), + maskHighBytes(bit.rshift(int, 8)), + maskHighBytes(int) + }, order) +end + +local function uint16ToBytes(int, order) + return fromLE({ + maskHighBytes(bit.rshift(int, 8)), + maskHighBytes(int) + }, order) +end + +function bit_converter.uint32_to_bytes(int, order) if int > MAX_UINT32 or int < MIN_UINT32 then error("invalid uint32") end - return { - intToByte(bit.rshift(int, 24)), - intToByte(bit.rshift(int, 16)), - intToByte(bit.rshift(int, 8)), - intToByte(int) - } + return uint32ToBytes(int, order) end -function bit_converter.uint16_to_bytes(int) +function bit_converter.uint16_to_bytes(int, order) if int > MAX_UINT16 or int < MIN_UINT16 then error("invalid uint16") end - return { - intToByte(bit.rshift(int, 8)), - intToByte(int) - } + return uint16ToBytes(int, order) end -function bit_converter.int64_to_bytes(int) +function bit_converter.int64_to_bytes(int, order) if int > MAX_INT64 or int < MIN_INT64 then error("invalid int64") end - return { - intToByte(bit.rshift(int, 56)), - intToByte(bit.rshift(int, 48)), - intToByte(bit.rshift(int, 40)), - intToByte(bit.rshift(int, 32)), - intToByte(bit.rshift(int, 24)), - intToByte(bit.rshift(int, 16)), - intToByte(bit.rshift(int, 8)), - intToByte(int) - } + return fromLE({ + maskHighBytes(bit.rshift(int, 56)), + maskHighBytes(bit.rshift(int, 48)), + maskHighBytes(bit.rshift(int, 40)), + maskHighBytes(bit.rshift(int, 32)), + maskHighBytes(bit.rshift(int, 24)), + maskHighBytes(bit.rshift(int, 16)), + maskHighBytes(bit.rshift(int, 8)), + maskHighBytes(int) + }, order) end -function bit_converter.int32_to_bytes(int) +function bit_converter.int32_to_bytes(int, order) + on_deprecated_call("bit_converter.int32_to_bytes", "bit_converter.sint32_to_bytes") + if int > MAX_INT32 or int < MIN_INT32 then error("invalid int32") end - return bit_converter.uint32_to_bytes(int + MAX_INT32) + return uint32ToBytes(int + MAX_INT32, order) end -function bit_converter.int16_to_bytes(int) +function bit_converter.int16_to_bytes(int, order) + on_deprecated_call("bit_converter.int32_to_bytes", "bit_converter.sint16_to_bytes") + if int > MAX_INT16 or int < MIN_INT16 then error("invalid int16") end - return bit_converter.uint16_to_bytes(int + MAX_INT16) + return uint16ToBytes(int + MAX_INT16, order) end -function bit_converter.bytes_to_single(bytes) - return bytesToFloatOrDouble(bytes, 'f') +function bit_converter.sint32_to_bytes(int, order) + if int > MAX_INT32 or int < MIN_INT32 then + error("invalid sint32") + end + + return uint32ToBytes(int + MAX_UINT32 + 1, order) end -function bit_converter.bytes_to_double(bytes) - return bytesToFloatOrDouble(bytes, 'd') +function bit_converter.sint16_to_bytes(int, order) + if int > MAX_INT16 or int < MIN_INT16 then + error("invalid sint16") + end + + return uint16ToBytes(int + MAX_UINT16 + 1, order) end -function bit_converter.bytes_to_string(bytes) +function bit_converter.bytes_to_float32(bytes, order) + return bytesToFloatOrDouble(toLE(bytes, order), 'f') +end + +function bit_converter.bytes_to_float64(bytes, order) + return bytesToFloatOrDouble(toLE(bytes, order), 'd') +end + +function bit_converter.bytes_to_single(bytes, order) + on_deprecated_call("bit_converter.bytes_to_single", "bit_converter.bytes_to_float32") + return bit_converter.bytes_to_float32(bytes, order) +end + +function bit_converter.bytes_to_double(bytes, order) + on_deprecated_call("bit_converter.bytes_to_double", "bit_converter.bytes_to_float64") + return bit_converter.bytes_to_float64(bytes, order) +end + +function bit_converter.bytes_to_string(bytes, order) local len = bit_converter.bytes_to_uint16({ bytes[1], bytes[2] }) local str = "" @@ -206,17 +287,13 @@ function bit_converter.byte_to_bool(byte) return byte ~= 0 end -function bit_converter.bytes_to_float(bytes) - if #bytes < 8 then - error("eof") - end - error("unsupported operation") -end - -function bit_converter.bytes_to_uint32(bytes) +function bit_converter.bytes_to_uint32(bytes, order) if #bytes < 4 then error("eof") end + + bytes = toLE(bytes, order) + return bit.bor( bit.bor( @@ -226,20 +303,26 @@ function bit_converter.bytes_to_uint32(bytes) bit.lshift(bytes[3], 8)),bytes[4]) end -function bit_converter.bytes_to_uint16(bytes) +function bit_converter.bytes_to_uint16(bytes, order) if #bytes < 2 then error("eof") end + + bytes = toLE(bytes, order) + return bit.bor( bit.lshift(bytes[1], 8), bytes[2], 0) end -function bit_converter.bytes_to_int64(bytes) +function bit_converter.bytes_to_int64(bytes, order) if #bytes < 8 then error("eof") end + + bytes = toLE(bytes, order) + return bit.bor( bit.bor( @@ -257,12 +340,26 @@ function bit_converter.bytes_to_int64(bytes) bit.lshift(bit.band(bytes[7], 0xFF), 8)),bit.band(bytes[8], 0xFF)) end -function bit_converter.bytes_to_int32(bytes) - return bit_converter.bytes_to_uint32(bytes) - MAX_INT32 +function bit_converter.bytes_to_int32(bytes, order) + on_deprecated_call("bit_converter.bytes_to_int32", "bit_converter.bytes_to_sint32") + return bit_converter.bytes_to_uint32(bytes, order) - MAX_INT32 end -function bit_converter.bytes_to_int16(bytes) - return bit_converter.bytes_to_uint16(bytes) - MAX_INT16 +function bit_converter.bytes_to_int16(bytes, order) + on_deprecated_call("bit_converter.bytes_to_int16", "bit_converter.bytes_to_sint16") + return bit_converter.bytes_to_uint16(bytes, order) - MAX_INT16 +end + +function bit_converter.bytes_to_sint32(bytes, order) + local num = bit_converter.bytes_to_uint32(bytes, order) + + return MIN_INT32 * (bit.band(MAX_INT32 + 1, num) ~= 0 and 1 or 0) + bit.band(MAX_INT32, num) +end + +function bit_converter.bytes_to_sint16(bytes, order) + local num = bit_converter.bytes_to_uint16(bytes, order) + + return MIN_INT16 * (bit.band(MAX_INT16 + 1, num) ~= 0 and 1 or 0) + bit.band(MAX_INT16, num) end return bit_converter diff --git a/res/modules/data_buffer.lua b/res/modules/data_buffer.lua index aafe63e7..e3d207ff 100644 --- a/res/modules/data_buffer.lua +++ b/res/modules/data_buffer.lua @@ -18,22 +18,31 @@ local TYPE_UINT32 = 2 local TYPE_INT16 = 3 local TYPE_INT32 = 4 local TYPE_INT64 = 5 -local TYPE_DOUBLE = 6 +local TYPE_FLOAT64 = 6 +local TYPE_SINT16 = 7 +local TYPE_SINT32 = 8 -- Data buffer local data_buffer = { __call = - function(data_buffer, bytes) - return data_buffer:new(bytes) + function(data_buffer, ...) + return data_buffer:new(...) end } -function data_buffer:new(bytes) +function data_buffer:new(bytes, order, useBytearray) + bytes = bytes or { } + + if order then bit_converter.validate_order(order) + else order = bit_converter.default_order end + local obj = { pos = 1, - bytes = bytes or { } + order = order, + useBytearray = useBytearray or false, + bytes = useBytearray and Bytearray(bytes) or bytes } self.__index = self @@ -42,6 +51,13 @@ function data_buffer:new(bytes) return obj end +function data_buffer:set_order(order) + bit_converter.validate_order(order) + + self.order = order + self.floatsOrder = order +end + -- Push functions function data_buffer:put_byte(byte) @@ -49,7 +65,8 @@ function data_buffer:put_byte(byte) error("invalid byte") end - self.bytes[self.pos] = byte + if self.useBytearray then self.bytes:insert(self.pos, byte) + else table.insert(self.bytes, self.pos, byte) end self.pos = self.pos + 1 end @@ -61,11 +78,21 @@ function data_buffer:put_bytes(bytes) end function data_buffer:put_single(single) - self:put_bytes(bit_converter.single_to_bytes(single)) + on_deprecated_call("data_buffer:put_single", "data_buffer:put_float32") + self:put_bytes(bit_converter.single_to_bytes(single, self.order)) end function data_buffer:put_double(double) - self:put_bytes(bit_converter.double_to_bytes(double)) + on_deprecated_call("data_buffer:put_single", "data_buffer:put_float64") + self:put_bytes(bit_converter.double_to_bytes(double, self.order)) +end + +function data_buffer:put_float32(single) + self:put_bytes(bit_converter.float32_to_bytes(single, self.order)) +end + +function data_buffer:put_float64(float) + self:put_bytes(bit_converter.float64_to_bytes(float, self.order)) end function data_buffer:put_string(str) @@ -77,23 +104,33 @@ function data_buffer:put_bool(bool) end function data_buffer:put_uint16(uint16) - self:put_bytes(bit_converter.uint16_to_bytes(uint16)) + self:put_bytes(bit_converter.uint16_to_bytes(uint16, self.order)) end function data_buffer:put_uint32(uint32) - self:put_bytes(bit_converter.uint32_to_bytes(uint32)) + self:put_bytes(bit_converter.uint32_to_bytes(uint32, self.order)) end function data_buffer:put_int16(int16) - self:put_bytes(bit_converter.int16_to_bytes(int16)) + on_deprecated_call("data_buffer:put_int16", "data_buffer:put_sint16") + self:put_bytes(bit_converter.int16_to_bytes(int16, self.order)) end function data_buffer:put_int32(int32) - self:put_bytes(bit_converter.int32_to_bytes(int32)) + on_deprecated_call("data_buffer:put_int32", "data_buffer:put_sint32") + self:put_bytes(bit_converter.int32_to_bytes(int32, self.order)) +end + +function data_buffer:put_sint16(int16) + self:put_bytes(bit_converter.sint16_to_bytes(int16, self.order)) +end + +function data_buffer:put_sint32(int32) + self:put_bytes(bit_converter.sint32_to_bytes(int32, self.order)) end function data_buffer:put_int64(int64) - self:put_bytes(bit_converter.int64_to_bytes(int64)) + self:put_bytes(bit_converter.int64_to_bytes(int64, self.order)) end function data_buffer:put_number(num) @@ -101,8 +138,8 @@ function data_buffer:put_number(num) local type if math.floor(num) ~= num then - type = TYPE_DOUBLE - bytes = bit_converter.double_to_bytes(num) + type = TYPE_FLOAT64 + bytes = bit_converter.float64_to_bytes(num) elseif num == 0 then type = TYPE_ZERO bytes = { } @@ -119,11 +156,11 @@ function data_buffer:put_number(num) end elseif num < 0 then if num >= MIN_INT16 then - type = TYPE_INT16 - bytes = bit_converter.int16_to_bytes(num) + type = TYPE_SINT16 + bytes = bit_converter.sint16_to_bytes(num) elseif num >= MIN_INT32 then - type = TYPE_INT32 - bytes = bit_converter.int32_to_bytes(num) + type = TYPE_SINT32 + bytes = bit_converter.sint32_to_bytes(num) elseif num >= MIN_INT64 then type = TYPE_INT64 bytes = bit_converter.int64_to_bytes(num) @@ -155,9 +192,13 @@ function data_buffer:get_number() return self:get_int16() elseif type == TYPE_INT32 then return self:get_int32() + elseif type == TYPE_SINT16 then + return self:get_sint16() + elseif type == TYPE_SINT32 then + return self:get_sint32() elseif type == TYPE_INT64 then return self:get_int64() - elseif type == TYPE_DOUBLE then + elseif type == TYPE_FLOAT64 then return self:get_double() else error("unknown lua number type: "..type) @@ -165,11 +206,21 @@ function data_buffer:get_number() end function data_buffer:get_single() - return bit_converter.bytes_to_single(self:get_bytes(4)) + on_deprecated_call("data_buffer:get_single", "data_buffer:get_float32") + return bit_converter.bytes_to_single(self:get_bytes(4), self.order) end function data_buffer:get_double() - return bit_converter.bytes_to_double(self:get_bytes(8)) + on_deprecated_call("data_buffer:get_double", "data_buffer:get_float64") + return bit_converter.bytes_to_double(self:get_bytes(8), self.order) +end + +function data_buffer:get_float32() + return bit_converter.bytes_to_float32(self:get_bytes(4), self.order) +end + +function data_buffer:get_float64() + return bit_converter.bytes_to_float64(self:get_bytes(8), self.order) end function data_buffer:get_string() @@ -193,23 +244,33 @@ function data_buffer:get_bool() end function data_buffer:get_uint16() - return bit_converter.bytes_to_uint16(self:get_bytes(2)) + return bit_converter.bytes_to_uint16(self:get_bytes(2), self.order) end function data_buffer:get_uint32() - return bit_converter.bytes_to_uint32(self:get_bytes(4)) + return bit_converter.bytes_to_uint32(self:get_bytes(4), self.order) end function data_buffer:get_int16() - return bit_converter.bytes_to_int16(self:get_bytes(2)) + on_deprecated_call("data_buffer:get_int16", "data_buffer:get_sint16") + return bit_converter.bytes_to_int16(self:get_bytes(2), self.order) end function data_buffer:get_int32() - return bit_converter.bytes_to_int32(self:get_bytes(4)) + on_deprecated_call("data_buffer:get_int32", "data_buffer:get_sint32") + return bit_converter.bytes_to_int32(self:get_bytes(4), self.order) +end + +function data_buffer:get_sint16() + return bit_converter.bytes_to_sint16(self:get_bytes(2), self.order) +end + +function data_buffer:get_sint32() + return bit_converter.bytes_to_sint32(self:get_bytes(4), self.order) end function data_buffer:get_int64() - return bit_converter.bytes_to_int64(self:get_bytes(8)) + return bit_converter.bytes_to_int64(self:get_bytes(8), self.order) end function data_buffer:size()