voxelcoreprojects/voxelcore
1
0
Fork 0
mirror of https://github.com/MihailRis/voxelcore.git synced 2026-10-12 14:31:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

all camelCase occurences in io_stream changed to snake_case

Browse source
This commit is contained in:
Onran 2026-07-24 03:14:47 +09:00
parent 36509fb7bc
commit 7d148ae2cf
1 changed files with 108 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

212
res/modules/io_stream.lua
View file

@ -25,13 +25,13 @@ local ALL_FLUSH_MODES = {
local CR = string.byte('\r') local CR = string.byte('\r')
local LF = string.byte('\n') local LF = string.byte('\n')
local function readFully(result, readFunc) local function read_fully(result, read_func)
local isTable = type(result) == "table" local isTable = type(result) == "table"
local buf local buf
repeat repeat
buf = readFunc(MAX_BUFFER_SIZE) buf = read_func(MAX_BUFFER_SIZE)
if isTable then if isTable then
for i = 1, #buf do for i = 1, #buf do
@ -59,29 +59,29 @@ ioLib - I/O library. Should include the following functions:
close(descriptor: int) close(descriptor: int)
--]] --]]
function io_stream.new(descriptor, binaryMode, ioLib, mode, flushMode) function io_stream.new(descriptor, binary_mode, io_lib, mode, flush_mode)
mode = mode or DEFAULT_MODE mode = mode or DEFAULT_MODE
flushMode = flushMode or FLUSH_MODE_ALL flush_mode = flush_mode or FLUSH_MODE_ALL
local self = setmetatable({}, io_stream) local self = setmetatable({}, io_stream)
self.descriptor = descriptor self.descriptor = descriptor
self.binaryMode = binaryMode self.binary_mode = binary_mode
self.maxBufferSize = MAX_BUFFER_SIZE self.max_buffer_size = MAX_BUFFER_SIZE
self.ioLib = ioLib self.io_lib = io_lib
self:set_mode(mode) self:set_mode(mode)
self:set_flush_mode(flushMode) self:set_flush_mode(flush_mode)
return self return self
end end
function io_stream:is_binary_mode() function io_stream:is_binary_mode()
return self.binaryMode return self.binary_mode
end end
function io_stream:set_binary_mode(binaryMode) function io_stream:set_binary_mode(binary_mode)
self.binaryMode = binaryMode ~= nil self.binary_mode = binary_mode ~= nil
end end
function io_stream:get_mode() function io_stream:get_mode()
@ -93,52 +93,52 @@ function io_stream:set_mode(mode)
error("invalid stream mode: "..mode) error("invalid stream mode: "..mode)
end end
if self.writeBuffer then if self.write_buffer then
self.writeBuffer:clear() self.write_buffer:clear()
self.writeBuffer = nil self.write_buffer = nil
end end
if self.readBuffer then if self.read_buffer then
self.readBuffer:clear() self.read_buffer:clear()
self.readBuffer = nil self.read_buffer = nil
end end
if mode == BUFFERED_MODE then if mode == BUFFERED_MODE then
self.writeBuffer = Bytearray(self.maxBufferSize) self.write_buffer = Bytearray(self.max_buffer_size)
self.readBuffer = Bytearray(self.maxBufferSize) self.read_buffer = Bytearray(self.max_buffer_size)
end end
self.mode = mode self.mode = mode
end end
function io_stream:get_flush_mode() function io_stream:get_flush_mode()
return self.flushMode return self.flush_mode
end end
function io_stream:set_flush_mode(flushMode) function io_stream:set_flush_mode(flush_mode)
if not table.has(ALL_FLUSH_MODES, flushMode) then if not table.has(ALL_FLUSH_MODES, flush_mode) then
error("invalid flush mode: "..flushMode) error("invalid flush mode: " .. flush_mode)
end end
self.flushMode = flushMode self.flush_mode = flush_mode
end end
function io_stream:get_max_buffer_size() function io_stream:get_max_buffer_size()
return self.maxBufferSize return self.max_buffer_size
end end
function io_stream:set_max_buffer_size(maxBufferSize) function io_stream:set_max_buffer_size(max_buffer_size)
self.maxBufferSize = maxBufferSize self.max_buffer_size = max_buffer_size
self.writeBuffer = Bytearray(self.maxBufferSize) self.write_buffer = Bytearray(self.max_buffer_size)
self.readBuffer = Bytearray(self.maxBufferSize) self.read_buffer = Bytearray(self.max_buffer_size)
end end
function io_stream:available(length) function io_stream:available(length)
local available = self.ioLib.available and self.ioLib.available(self.descriptor) or 0 local available = self.io_lib.available and self.io_lib.available(self.descriptor) or 0
if self.mode == BUFFERED_MODE then if self.mode == BUFFERED_MODE then
available = available + #self.readBuffer available = available + #self.read_buffer
end end
if not length then if not length then
@ -148,86 +148,86 @@ function io_stream:available(length)
end end
end end
function io_stream:__read(length, fromReadFully) function io_stream:__read(length, from_read_fully)
if self.mode == YIELD_MODE then if self.mode == YIELD_MODE then
if fromReadFully then if from_read_fully then
return self.ioLib.read(self.descriptor, length) return self.io_lib.read(self.descriptor, length)
end end
local buffer = Bytearray() local buffer = Bytearray()
while #buffer < length do while #buffer < length do
buffer:append(self.ioLib.read(self.descriptor, length - #buffer)) buffer:append(self.io_lib.read(self.descriptor, length - #buffer))
if #buffer < length then coroutine.yield() end if #buffer < length then coroutine.yield() end
end end
return buffer return buffer
elseif self.mode == BUFFERED_MODE then elseif self.mode == BUFFERED_MODE then
local bufLen = #self.readBuffer local buf_len = #self.read_buffer
if bufLen < length then if bufLen < length then
self.readBuffer:append( self.read_buffer:append(
self.ioLib.read(self.descriptor, self.maxBufferSize - bufLen) self.io_lib.read(self.descriptor, self.max_buffer_size - buf_len)
) )
end end
bufLen = #self.readBuffer bufLen = #self.read_buffer
length = math.min(bufLen, length) length = math.min(buf_len, length)
local copy = self.readBuffer:slice(1, length) local copy = self.read_buffer:slice(1, length)
if bufLen == length then if bufLen == length then
self.readBuffer:clear() self.read_buffer:clear()
else else
self.readBuffer:remove(1, length) self.read_buffer:remove(1, length)
end end
return copy return copy
elseif self.mode == DEFAULT_MODE then elseif self.mode == DEFAULT_MODE then
return self.ioLib.read(self.descriptor, length) return self.io_lib.read(self.descriptor, length)
end end
end end
function io_stream:__write(data) function io_stream:__write(data)
if self.mode == BUFFERED_MODE then if self.mode == BUFFERED_MODE then
local dataLength = #data local data_length = #data
if #self.writeBuffer + dataLength > self.maxBufferSize then if #self.write_buffer + data_length > self.max_buffer_size then
self:flush() self:flush()
end end
if dataLength > self.maxBufferSize then if data_length > self.max_buffer_size then
local toWrite = math.floor(dataLength / self.maxBufferSize) * self.maxBufferSize local to_write = math.floor(data_length / self.max_buffer_size) * self.max_buffer_size
local toSave = dataLength - toWrite local to_save = data_length - to_write
self.ioLib.write(self.descriptor, data:slice(1, toWrite)) self.io_lib.write(self.descriptor, data:slice(1, to_write))
self:flush() self:flush()
self.writeBuffer = data:slice(toWrite + 1, toSave) self.write_buffer = data:slice(to_write + 1, to_save)
else self.writeBuffer:append(data) end else self.write_buffer:append(data) end
elseif self.mode == DEFAULT_MODE or self.mode == YIELD_MODE then elseif self.mode == DEFAULT_MODE or self.mode == YIELD_MODE then
return self.ioLib.write(self.descriptor, data) return self.io_lib.write(self.descriptor, data)
end end
end end
function io_stream:read_fully(useTable) function io_stream:read_fully(use_table)
if self.binaryMode then if self.binary_mode then
local result = useTable and Bytearray() or { } local result = use_table and { } or Bytearray()
local avail = self:available() local avail = self:available()
if avail == 0 then if avail == 0 then
avail = self.maxBufferSize avail = self.max_buffer_size
end end
readFully(result, function() return self:__read(avail, true) end) read_fully(result, function() return self:__read(avail, true) end)
return result return result
else else
if useTable then if use_table then
local lines = { } local lines = { }
local line local line
@ -242,7 +242,7 @@ function io_stream:read_fully(useTable)
else else
local result = Bytearray() local result = Bytearray()
readFully(result, function() return self:__read(self.maxBufferSize) end) read_fully(result, function() return self:__read(self.max_buffer_size) end)
return utf8.tostring(result) return utf8.tostring(result)
end end
@ -284,57 +284,61 @@ function io_stream:write_line(str)
self:__write(utf8.tobytes(str .. "\n")) self:__write(utf8.tobytes(str .. "\n"))
end end
function io_stream:read(arg, useTable) function io_stream:read(arg, use_table)
local argType = type(arg) local arg_type = type(arg)
if self.binaryMode then if self.binary_mode then
local byteArr local byte_arr
if argType == "number" then if arg_type == "number" then
-- using 'arg' as length -- using 'arg' as length
byteArr = self:__read(arg) byte_arr = self:__read(arg)
if useTable == true then if use_table == true then
local t = { } local t = { }
for i = 1, #byteArr do for i = 1, #byte_arr do
t[i] = byteArr[i] t[i] = byte_arr[i]
end end
return t return t
else else
return byteArr return byte_arr
end end
elseif argType == "string" then elseif arg_type == "string" then
return byteutil.unpack( return byteutil.unpack(
arg, arg,
self:__read(byteutil.get_size(arg)) self:__read(byteutil.get_size(arg))
) )
elseif argType == nil then elseif arg_type == "nil" then
error( error(
"in binary mode the first argument must be a string data format".. "in binary mode the first argument must be a string data format"..
" for the library \"byteutil\" or the number of bytes to read" " for the library \"byteutil\" or the number of bytes to read"
) )
else else
error("unknown argument type: "..argType) error("unknown argument type: "..arg_type)
end end
else else
if not arg then if not arg then
return self:read_line() return self:read_line()
else else
local linesCount = arg local lines_count = arg
local trimLastEmptyLines = useTable or true local trim_last_empty_lines = use_table
if linesCount < 0 then error "count of lines to read must be positive" end if use_table == nil then
trim_last_empty_lines = true
end
if lines_count < 0 then error "count of lines to read must be positive" end
local result = { } local result = { }
for i = 1, linesCount do for i = 1, lines_count do
result[i] = self:read_line() result[i] = self:read_line()
end end
if trimLastEmptyLines then if trim_last_empty_lines then
local i = #result local i = #result
while i >= 0 do while i >= 0 do
@ -362,53 +366,53 @@ function io_stream:read(arg, useTable)
end end
function io_stream:write(arg, ...) function io_stream:write(arg, ...)
local argType = type(arg) local arg_type = type(arg)
if self.binaryMode then if self.binary_mode then
local byteArr local byte_arr
if argType ~= "string" then if arg_type ~= "string" then
-- using arg as bytes table/bytearray -- using arg as bytes table/bytearray
if argType == "table" then if arg_type == "table" then
byteArr = Bytearray(arg) byte_arr = Bytearray(arg)
else else
byteArr = arg byte_arr = arg
end end
else else
byteArr = byteutil.pack(arg, ...) byte_arr = byteutil.pack(arg, ...)
end end
self:__write(byteArr) self:__write(byte_arr)
else else
if argType == "string" then if arg_type == "string" then
self:write_line(arg) self:write_line(arg)
elseif argType == "table" then elseif argType == "table" then
for i = 1, #arg do for i = 1, #arg do
self:write_line(arg[i]) self:write_line(arg[i])
end end
else error("unknown argument type: "..argType) end else error("unknown argument type: "..arg_type) end
end end
end end
function io_stream:seek(mode, offset) function io_stream:seek(mode, offset)
if not self.ioLib.seek then if not self.io_lib.seek then
error("cannot seek this stream") error("cannot seek this stream")
end end
self.ioLib.seek(self.descriptor, mode, offset) self.io_lib.seek(self.descriptor, mode, offset)
end end
function io_stream:tell() function io_stream:tell()
if not self.ioLib.tell then if not self.io_lib.tell then
error("cannot tell this stream") error("cannot tell this stream")
end end
return self.ioLib.tell(self.descriptor) return self.io_lib.tell(self.descriptor)
end end
function io_stream:is_alive() function io_stream:is_alive()
return self.ioLib.is_alive(self.descriptor) return self.io_lib.is_alive(self.descriptor)
end end
function io_stream:is_closed() function io_stream:is_closed()
@ -417,24 +421,24 @@ end
function io_stream:close() function io_stream:close()
if self.mode == BUFFERED_MODE then if self.mode == BUFFERED_MODE then
self.readBuffer:clear() self.read_buffer:clear()
self.writeBuffer:clear() self.write_buffer:clear()
end end
return self.ioLib.close(self.descriptor) return self.io_lib.close(self.descriptor)
end end
function io_stream:flush() function io_stream:flush()
if self.mode == BUFFERED_MODE and #self.writeBuffer > 0 then if self.mode == BUFFERED_MODE and #self.write_buffer > 0 then
self.ioLib.write(self.descriptor, self.writeBuffer) self.io_lib.write(self.descriptor, self.write_buffer)
self.writeBuffer:clear() self.write_buffer:clear()
end end
if self.flushMode ~= FLUSH_MODE_ONLY_BUFFER then if self.flush_mode ~= FLUSH_MODE_ONLY_BUFFER then
if self.ioLib.flush then if self.io_lib.flush then
self.ioLib.flush(self.descriptor) self.io_lib.flush(self.descriptor)
elseif self:is_closed() then error("stream is closed") end elseif self:is_closed() then error("stream is closed") end
end end
end end
return io_stream return io_stream