From 07702f9e57fd0e2fd2ebcae00e3f5f8c6ae3c885 Mon Sep 17 00:00:00 2001 From: MihailRis Date: Wed, 10 Jun 2026 23:08:48 +0300 Subject: [PATCH] refactor descriptors_manager --- .../internal/stream_providers/file.lua | 13 +- src/logic/scripting/descriptors_manager.cpp | 104 ---------------- src/logic/scripting/descriptors_manager.hpp | 39 ------ src/logic/scripting/io_descriptors.cpp | 111 ++++++++++++++++++ src/logic/scripting/io_descriptors.hpp | 23 ++++ src/logic/scripting/lua/libs/libfile.cpp | 42 +++---- 6 files changed, 166 insertions(+), 166 deletions(-) delete mode 100644 src/logic/scripting/descriptors_manager.cpp delete mode 100644 src/logic/scripting/descriptors_manager.hpp create mode 100644 src/logic/scripting/io_descriptors.cpp create mode 100644 src/logic/scripting/io_descriptors.hpp diff --git a/res/modules/internal/stream_providers/file.lua b/res/modules/internal/stream_providers/file.lua index ec81a42c0..484e869e4 100644 --- a/res/modules/internal/stream_providers/file.lua +++ b/res/modules/internal/stream_providers/file.lua @@ -9,10 +9,19 @@ local lib = { close = file.__close_descriptor } +local __open_descriptor = file.__open_descriptor +file.__open_descriptor = nil +file.__read_descriptor = nil +file.__write_descriptor = nil +file.__seek_descriptor = nil +file.__flush_descriptor = nil +file.__has_descriptor = nil +file.__close_descriptor = nil + return function(path, mode) return io_stream.new( - file.__open_descriptor(path, mode), + __open_descriptor(path, mode), mode:find('b') ~= nil, lib ) -end \ No newline at end of file +end diff --git a/src/logic/scripting/descriptors_manager.cpp b/src/logic/scripting/descriptors_manager.cpp deleted file mode 100644 index f7458ccc5..000000000 --- a/src/logic/scripting/descriptors_manager.cpp +++ /dev/null @@ -1,104 +0,0 @@ -#include "logic/scripting/descriptors_manager.hpp" - -#include "debug/Logger.hpp" - -static debug::Logger logger("descriptors-manager"); - -namespace scripting { - - std::vector> descriptors_manager::descriptors; - - std::istream* descriptors_manager::get_input(int descriptor) { - if (!is_readable(descriptor)) - return nullptr; - - return descriptors[descriptor]->in.get(); - } - - std::ostream* descriptors_manager::get_output(int descriptor) { - if (!is_writeable(descriptor)) - return nullptr; - - return descriptors[descriptor]->out.get(); - } - - void descriptors_manager::flush(int descriptor) { - if (is_writeable(descriptor)) { - descriptors[descriptor]->out->flush(); - } - } - - bool descriptors_manager::has_descriptor(int descriptor) { - return is_readable(descriptor) || is_writeable(descriptor); - } - - bool descriptors_manager::is_readable(int descriptor) { - return descriptor >= 0 && descriptor < static_cast(descriptors.size()) - && descriptors[descriptor].has_value() - && descriptors[descriptor]->in != nullptr; - } - - bool descriptors_manager::is_writeable(int descriptor) { - return descriptor >= 0 && descriptor < static_cast(descriptors.size()) - && descriptors[descriptor].has_value() - && descriptors[descriptor]->out != nullptr; - } - - void descriptors_manager::close(int descriptor) { - if (descriptor >= 0 && descriptor < static_cast(descriptors.size())) { - if (descriptors[descriptor].has_value()) { - auto& desc = descriptors[descriptor].value(); - - if (desc.out) - desc.out->flush(); - - desc.in.reset(); - desc.out.reset(); - } - - descriptors[descriptor].reset(); - - descriptors[descriptor] = std::nullopt; - } - } - - int descriptors_manager::open_descriptor(const io::path& path, bool write, bool read) { - std::unique_ptr in; - std::unique_ptr out; - - try { - if (read) - in = io::read(path); - - if (write) - out = io::write(path); - } catch (const std::exception& e) { - logger.error() << "failed to open descriptor for " << path.string() - << ": " << e.what(); - - return -1; - } - - for (int i = 0; i < static_cast(descriptors.size()); ++i) { - if (!descriptors[i].has_value()) { - descriptors[i] = StreamDescriptor{ std::move(in), std::move(out) }; - return i; - } - } - - descriptors.emplace_back(StreamDescriptor{ std::move(in), std::move(out) }); - - return static_cast(descriptors.size() - 1); - } - - - void descriptors_manager::close_all_descriptors() { - for (int i = 0; i < static_cast(descriptors.size()); ++i) { - if (descriptors[i].has_value()) { - close(i); - } - } - - descriptors.clear(); - } -} \ No newline at end of file diff --git a/src/logic/scripting/descriptors_manager.hpp b/src/logic/scripting/descriptors_manager.hpp deleted file mode 100644 index ccd1b67a3..000000000 --- a/src/logic/scripting/descriptors_manager.hpp +++ /dev/null @@ -1,39 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include - -#include "io/io.hpp" - -namespace scripting { - - struct StreamDescriptor { - std::unique_ptr in; - std::unique_ptr out; - }; - - class descriptors_manager { - private: - static std::vector> descriptors; - - public: - static std::istream* get_input(int descriptor); - static std::ostream* get_output(int descriptor); - - static void flush(int descriptor); - - static bool has_descriptor(int descriptor); - - static bool is_readable(int descriptor); - static bool is_writeable(int descriptor); - - static void close(int descriptor); - static int open_descriptor(const io::path& path, bool write, bool read); - - static void close_all_descriptors(); - }; -} \ No newline at end of file diff --git a/src/logic/scripting/io_descriptors.cpp b/src/logic/scripting/io_descriptors.cpp new file mode 100644 index 000000000..e6fda04dc --- /dev/null +++ b/src/logic/scripting/io_descriptors.cpp @@ -0,0 +1,111 @@ +#include "logic/scripting/io_descriptors.hpp" + +#include "debug/Logger.hpp" +#include "io/io.hpp" + +#include +#include +#include +#include + +static debug::Logger logger("descriptors-manager"); + +using namespace scripting; + +namespace { + struct StreamDescriptor { + std::unique_ptr in; + std::unique_ptr out; + }; + std::vector> descriptors; +} + +std::istream* io_descriptors::get_input(int id) { + if (!is_readable(id)) { + return nullptr; + } + return ::descriptors[id]->in.get(); +} + +std::ostream* io_descriptors::get_output(int id) { + if (!is_writeable(id)) { + return nullptr; + } + return ::descriptors[id]->out.get(); +} + +void io_descriptors::flush(int id) { + if (is_writeable(id)) { + ::descriptors[id]->out->flush(); + } +} + +bool io_descriptors::has_descriptor(int id) { + return id >= 0 && id < static_cast(::descriptors.size()) && + ::descriptors[id].has_value() && + (::descriptors[id]->in != nullptr || + ::descriptors[id]->out != nullptr); +} + +bool io_descriptors::is_readable(int id) { + return id >= 0 && id < static_cast(::descriptors.size()) + && ::descriptors[id].has_value() + && ::descriptors[id]->in != nullptr; +} + +bool io_descriptors::is_writeable(int id) { + return id >= 0 && id < static_cast(::descriptors.size()) + && ::descriptors[id].has_value() + && ::descriptors[id]->out != nullptr; +} + +void io_descriptors::close(int id) { + if (!has_descriptor(id)) { + return; + } + auto& desc = ::descriptors[id].value(); + if (desc.out) { + desc.out->flush(); + } + desc.in.reset(); + desc.out.reset(); + ::descriptors[id] = std::nullopt; +} + +int io_descriptors::open_descriptor(const io::path& path, bool write, bool read) { + std::unique_ptr in; + std::unique_ptr out; + + try { + if (read) { + in = io::read(path); + } + if (write) { + out = io::write(path); + } + } catch (const std::exception& e) { + logger.error() << "failed to open descriptor for " << path.string() + << ": " << e.what(); + return -1; + } + + for (int i = 0; i < static_cast(descriptors.size()); ++i) { + if (!descriptors[i].has_value()) { + descriptors[i] = StreamDescriptor{ std::move(in), std::move(out) }; + return i; + } + } + + ::descriptors.emplace_back(StreamDescriptor{ std::move(in), std::move(out) }); + return static_cast(::descriptors.size() - 1); +} + + +void io_descriptors::close_all_descriptors() { + for (int i = 0; i < static_cast(::descriptors.size()); ++i) { + if (::descriptors[i].has_value()) { + close(i); + } + } + ::descriptors.clear(); +} diff --git a/src/logic/scripting/io_descriptors.hpp b/src/logic/scripting/io_descriptors.hpp new file mode 100644 index 000000000..0400a920a --- /dev/null +++ b/src/logic/scripting/io_descriptors.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include +#include + +#include "io/fwd.hpp" + +namespace scripting::io_descriptors { + std::istream* get_input(int id); + std::ostream* get_output(int id); + + void flush(int id); + + bool has_descriptor(int id); + + bool is_readable(int id); + bool is_writeable(int id); + + void close(int id); + int open_descriptor(const io::path& path, bool write, bool read); + + void close_all_descriptors(); +} diff --git a/src/logic/scripting/lua/libs/libfile.cpp b/src/logic/scripting/lua/libs/libfile.cpp index 26248379c..964c6d487 100644 --- a/src/logic/scripting/lua/libs/libfile.cpp +++ b/src/logic/scripting/lua/libs/libfile.cpp @@ -10,7 +10,7 @@ #include "util/stringutil.hpp" #include "api_lua.hpp" #include "../lua_engine.hpp" -#include "logic/scripting/descriptors_manager.hpp" +#include "logic/scripting/io_descriptors.hpp" namespace fs = std::filesystem; using namespace scripting; @@ -263,13 +263,13 @@ static int l_open_descriptor(lua::State* L) { std::vector buffer; if(wplusMode) { - int temp_descriptor = scripting::descriptors_manager::open_descriptor(path, false, true); + int temp_descriptor = io_descriptors::open_descriptor(path, false, true); if (temp_descriptor == -1) { throw std::runtime_error("failed to open descriptor for initial reading"); } - auto* in_stream = scripting::descriptors_manager::get_input(temp_descriptor); + auto* in_stream = io_descriptors::get_input(temp_descriptor); in_stream->seekg(0, std::ios::end); std::streamsize size = in_stream->tellg(); @@ -278,17 +278,17 @@ static int l_open_descriptor(lua::State* L) { buffer.resize(size); in_stream->read(buffer.data(), size); - scripting::descriptors_manager::close(temp_descriptor); + io_descriptors::close(temp_descriptor); } - int descriptor = scripting::descriptors_manager::open_descriptor(path, write, read); + int descriptor = io_descriptors::open_descriptor(path, write, read); if(descriptor == -1) { throw std::runtime_error("failed to open descriptor"); } if(wplusMode) { - auto* out_stream = scripting::descriptors_manager::get_output(descriptor); + auto* out_stream = io_descriptors::get_output(descriptor); out_stream->write(buffer.data(), buffer.size()); out_stream->flush(); } @@ -297,23 +297,23 @@ static int l_open_descriptor(lua::State* L) { } static int l_has_descriptor(lua::State* L) { - return lua::pushboolean(L, scripting::descriptors_manager::has_descriptor(lua::tointeger(L, 1))); + return lua::pushboolean(L, io_descriptors::has_descriptor(lua::tointeger(L, 1))); } static int l_read_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); - if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + if (!io_descriptors::has_descriptor(descriptor)) { throw std::runtime_error("unknown descriptor"); } - if (!scripting::descriptors_manager::is_readable(descriptor)) { + if (!io_descriptors::is_readable(descriptor)) { throw std::runtime_error("descriptor is not readable"); } int maxlen = lua::tointeger(L, 2); - auto* stream = scripting::descriptors_manager::get_input(descriptor); + auto* stream = io_descriptors::get_input(descriptor); util::Buffer buffer(maxlen); @@ -327,17 +327,17 @@ static int l_read_descriptor(lua::State* L) { static int l_write_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); - if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + if (!io_descriptors::has_descriptor(descriptor)) { throw std::runtime_error("unknown descriptor"); } - if (!scripting::descriptors_manager::is_writeable(descriptor)) { + if (!io_descriptors::is_writeable(descriptor)) { throw std::runtime_error("descriptor is not writeable"); } auto data = lua::bytearray_as_string(L, 2); - auto* stream = scripting::descriptors_manager::get_output(descriptor); + auto* stream = io_descriptors::get_output(descriptor); stream->write(data.data(), static_cast(data.size())); @@ -350,7 +350,7 @@ static int l_write_descriptor(lua::State* L) { static int l_seek_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); - if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + if (!io_descriptors::has_descriptor(descriptor)) { throw std::runtime_error("unknown descriptor"); } @@ -371,7 +371,7 @@ static int l_seek_descriptor(lua::State* L) { throw std::runtime_error("invalid seek mode"); } - auto* stream = scripting::descriptors_manager::get_output(descriptor); + auto* stream = io_descriptors::get_output(descriptor); stream->seekp(lua::tointeger(L, 3), dir); @@ -385,31 +385,31 @@ static int l_seek_descriptor(lua::State* L) { static int l_flush_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); - if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + if (!io_descriptors::has_descriptor(descriptor)) { throw std::runtime_error("unknown descriptor"); } - if (!scripting::descriptors_manager::is_writeable(descriptor)) { + if (!io_descriptors::is_writeable(descriptor)) { throw std::runtime_error("descriptor is not writeable"); } - scripting::descriptors_manager::flush(descriptor); + io_descriptors::flush(descriptor); return 0; } static int l_close_descriptor(lua::State* L) { int descriptor = lua::tointeger(L, 1); - if (!scripting::descriptors_manager::has_descriptor(descriptor)) { + if (!io_descriptors::has_descriptor(descriptor)) { throw std::runtime_error("unknown descriptor"); } - scripting::descriptors_manager::close(descriptor); + io_descriptors::close(descriptor); return 0; } static int l_close_all_descriptors(lua::State* L) { - scripting::descriptors_manager::close_all_descriptors(); + io_descriptors::close_all_descriptors(); return 0; }