mirror of
https://github.com/GreenComfyTea/MHR-Overlay.git
synced 2026-01-24 04:18:11 -08:00
Merge table_helpers and unicode_helpers into utils
This commit is contained in:
GreenComfyTea
@@ -1,4 +1,4 @@
|
||||
local utils = {};
|
||||
local this = {};
|
||||
|
||||
local sdk = sdk;
|
||||
local tostring = tostring;
|
||||
@@ -28,16 +28,392 @@ local imgui = imgui;
|
||||
local draw = draw;
|
||||
local Vector2f = Vector2f;
|
||||
local reframework = reframework;
|
||||
local os = os;
|
||||
local ValueType = ValueType;
|
||||
local package = package;
|
||||
|
||||
function utils.sign(v)
|
||||
return (v >= 0 and 1) or -1;
|
||||
local table_tostring;
|
||||
local deep_copy;
|
||||
local merge;
|
||||
local is_empty;
|
||||
local unicode_map;
|
||||
local unicode_relative_position;
|
||||
local unicode_chars;
|
||||
|
||||
this.table = {};
|
||||
this.number = {};
|
||||
this.string = {};
|
||||
this.vec2 = {};
|
||||
this.vec3 = {};
|
||||
this.vec4 = {};
|
||||
this.math = {};
|
||||
this.unicode = {};
|
||||
|
||||
function this.table.tostring(table_)
|
||||
if type(table_) == "number" or type(table_) == "boolean" or type(table_) == "string" then
|
||||
return tostring(table_);
|
||||
end
|
||||
|
||||
if is_empty(table_) then
|
||||
return "{}";
|
||||
end
|
||||
|
||||
local cache = {};
|
||||
local stack = {};
|
||||
local output = {};
|
||||
local depth = 1;
|
||||
local output_str = "{\n";
|
||||
|
||||
while true do
|
||||
local size = 0;
|
||||
for k,v in pairs(table_) do
|
||||
size = size + 1;
|
||||
end
|
||||
|
||||
local cur_index = 1;
|
||||
for k,v in pairs(table_) do
|
||||
if cache[table_] == nil or cur_index >= cache[table_] then
|
||||
|
||||
if string.find(output_str, "}", output_str:len()) then
|
||||
output_str = output_str .. ",\n";
|
||||
elseif not string.find(output_str, "\n", output_str:len()) then
|
||||
output_str = output_str .. "\n";
|
||||
end
|
||||
|
||||
-- This is necessary for working with HUGE tables otherwise we run out of memory using concat on huge strings
|
||||
table.insert(output,output_str);
|
||||
output_str = "";
|
||||
|
||||
local key;
|
||||
if type(k) == "number" or type(k) == "boolean" then
|
||||
key = "[" .. tostring(k) .. "]";
|
||||
else
|
||||
key = "['" .. tostring(k) .. "']";
|
||||
end
|
||||
|
||||
if type(v) == "number" or type(v) == "boolean" then
|
||||
output_str = output_str .. string.rep('\t', depth) .. key .. " = "..tostring(v);
|
||||
elseif type(v) == "table" then
|
||||
output_str = output_str .. string.rep('\t', depth) .. key .. " = {\n";
|
||||
table.insert(stack, table_);
|
||||
table.insert(stack, v);
|
||||
cache[table_] = cur_index + 1;
|
||||
break;
|
||||
else
|
||||
output_str = output_str .. string.rep('\t', depth) .. key .. " = '" .. tostring(v) .. "'";
|
||||
end
|
||||
|
||||
if cur_index == size then
|
||||
output_str = output_str .. "\n" .. string.rep('\t', depth - 1) .. "}";
|
||||
else
|
||||
output_str = output_str .. ",";
|
||||
end
|
||||
else
|
||||
-- close the table
|
||||
if cur_index == size then
|
||||
output_str = output_str .. "\n" .. string.rep('\t', depth - 1) .. "}";
|
||||
end
|
||||
end
|
||||
|
||||
cur_index = cur_index + 1;
|
||||
end
|
||||
|
||||
if size == 0 then
|
||||
output_str = output_str .. "\n" .. string.rep('\t', depth - 1) .. "}";
|
||||
end
|
||||
|
||||
if #stack > 0 then
|
||||
table_ = stack[#stack];
|
||||
stack[#stack] = nil;
|
||||
depth = cache[table_] == nil and depth + 1 or depth - 1;
|
||||
else
|
||||
break;
|
||||
end
|
||||
end
|
||||
|
||||
-- This is necessary for working with HUGE tables otherwise we run out of memory using concat on huge strings
|
||||
table.insert(output, output_str);
|
||||
output_str = table.concat(output);
|
||||
|
||||
return output_str;
|
||||
end
|
||||
function utils.round(value, bracket)
|
||||
|
||||
function this.table.tostringln(table_)
|
||||
return "\n" .. table_tostring(table_);
|
||||
end
|
||||
|
||||
function this.table.is_empty(table_)
|
||||
return next(table_) == nil;
|
||||
end
|
||||
|
||||
function this.table.deep_copy(original, copies)
|
||||
copies = copies or {};
|
||||
local original_type = type(original);
|
||||
local copy;
|
||||
if original_type == "table" then
|
||||
if copies[original] then
|
||||
copy = copies[original];
|
||||
else
|
||||
copy = {};
|
||||
copies[original] = copy;
|
||||
for original_key, original_value in next, original, nil do
|
||||
copy[deep_copy(original_key, copies)] = deep_copy(original_value,copies);
|
||||
end
|
||||
setmetatable(copy, deep_copy(getmetatable(original), copies));
|
||||
end
|
||||
else -- number, string, boolean, etc
|
||||
copy = original;
|
||||
end
|
||||
return copy;
|
||||
end
|
||||
|
||||
function this.table.find_index(table_, value, nullable)
|
||||
for i = 1, #table_ do
|
||||
if table_[i] == value then
|
||||
return i;
|
||||
end
|
||||
end
|
||||
|
||||
if not nullable then
|
||||
return 1;
|
||||
end
|
||||
|
||||
return nil;
|
||||
end
|
||||
|
||||
function this.table.merge(...)
|
||||
local tables_to_merge = { ... };
|
||||
assert(#tables_to_merge > 1, "There should be at least two tables to merge them");
|
||||
|
||||
for key, table_ in ipairs(tables_to_merge) do
|
||||
assert(type(table_) == "table", string.format("Expected a table as function parameter %d", key));
|
||||
end
|
||||
|
||||
local result = deep_copy(tables_to_merge[1]);
|
||||
|
||||
for i = 2, #tables_to_merge do
|
||||
local from = tables_to_merge[i];
|
||||
for key, value in pairs(from) do
|
||||
if type(value) == "table" then
|
||||
result[key] = result[key] or {};
|
||||
assert(type(result[key]) == "table", string.format("Expected a table: '%s'", key));
|
||||
result[key] = merge(result[key], value);
|
||||
else
|
||||
result[key] = value;
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return result;
|
||||
end
|
||||
|
||||
function this.number.is_NaN(value)
|
||||
return tostring(value) == tostring(0/0);
|
||||
end
|
||||
|
||||
function this.number.round(value)
|
||||
return math.floor(value + 0.5);
|
||||
end
|
||||
|
||||
function this.string.trim(str)
|
||||
return str:match("^%s*(.-)%s*$");
|
||||
end
|
||||
|
||||
function this.string.starts_with(str, pattern)
|
||||
return str:find("^" .. pattern) ~= nil;
|
||||
end
|
||||
|
||||
function this.vec2.tostring(vector2f)
|
||||
return string.format("<%f, %f>", vector2f.x, vector2f.y);
|
||||
end
|
||||
|
||||
function this.vec2.random(distance)
|
||||
distance = distance or 1;
|
||||
local radians = math.random() * math.pi * 2;
|
||||
return Vector2f.new(
|
||||
distance * math.cos(radians),
|
||||
distance * math.sin(radians)
|
||||
);
|
||||
end
|
||||
|
||||
function this.vec3.tostring(vector3f)
|
||||
return string.format("<%f, %f, %f>", vector3f.x, vector3f.y, vector3f.z);
|
||||
end
|
||||
|
||||
function this.vec4.tostring(vector4f)
|
||||
return string.format("<%f, %f, %f, %f>", vector4f.x, vector4f.y, vector4f.z, vector4f.w);
|
||||
end
|
||||
|
||||
--- When called without arguments, returns a pseudo-random float with uniform distribution in the range [0,1). When called with two floats min and max, math.random returns a pseudo-random float with uniform distribution in the range [min, max). The call .random(max) is equivalent to .random(1, max)
|
||||
---@param min number
|
||||
---@param max number
|
||||
---@return number
|
||||
function this.math.random(min, max)
|
||||
if min == nil and max == nil then
|
||||
return math.random();
|
||||
end
|
||||
|
||||
if max == nil then
|
||||
return max * math.random();
|
||||
end
|
||||
|
||||
return min + (max - min) * math.random();
|
||||
end
|
||||
|
||||
function this.math.sign(value)
|
||||
return (value >= 0 and 1) or -1;
|
||||
end
|
||||
function this.math.round(value, bracket)
|
||||
bracket = bracket or 1;
|
||||
return math.floor(value / bracket + utils.sign(value) * 0.5) * bracket;
|
||||
return math.floor(value / bracket + this.math.sign(value) * 0.5) * bracket;
|
||||
end
|
||||
|
||||
function utils.init_module()
|
||||
-- https://github.com/blitmap/lua-utf8-simple/blob/master/utf8_simple.lua
|
||||
|
||||
-- ABNF from RFC 3629
|
||||
--
|
||||
-- UTF8-octets = *( UTF8-char )
|
||||
-- UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4
|
||||
-- UTF8-1 = %x00-7F
|
||||
-- UTF8-2 = %xC2-DF UTF8-tail
|
||||
-- UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
|
||||
-- %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
|
||||
-- UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
|
||||
-- %xF4 %x80-8F 2( UTF8-tail )
|
||||
-- UTF8-tail = %x80-BF
|
||||
|
||||
-- 0xxxxxxx | 007F (127)
|
||||
-- 110xxxxx 10xxxxxx | 07FF (2047)
|
||||
-- 1110xxxx 10xxxxxx 10xxxxxx | FFFF (65535)
|
||||
-- 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx | 10FFFF (1114111)
|
||||
|
||||
local pattern = "[%z\1-\127\194-\244][\128-\191]*";
|
||||
|
||||
-- helper function
|
||||
function this.unicode.relative_position(position, length)
|
||||
if position < 0 then
|
||||
position = length + position + 1;
|
||||
end
|
||||
return position;
|
||||
end
|
||||
|
||||
return utils;
|
||||
-- THE MEAT
|
||||
|
||||
-- maps f over s's utf8 characters f can accept args: (visual_index, utf8_character, byte_index)
|
||||
function this.unicode.map(s, f, no_subs)
|
||||
local i = 0;
|
||||
|
||||
if no_subs then
|
||||
for b, e in s:gmatch("()" .. pattern .. "()") do
|
||||
i = i + 1;
|
||||
local c = e - b;
|
||||
f(i, c, b);
|
||||
end
|
||||
else
|
||||
for b, c in s:gmatch("()(" .. pattern .. ")") do
|
||||
i = i + 1;
|
||||
f(i, c, b);
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- THE REST
|
||||
|
||||
-- returns the number of characters in a UTF-8 string
|
||||
function this.unicode.len(s)
|
||||
-- count the number of non-continuing bytes
|
||||
return select(2, s:gsub('[^\128-\193]', ''));
|
||||
end
|
||||
|
||||
-- replace all utf8 chars with mapping
|
||||
function this.unicode.replace(s, map)
|
||||
return s:gsub(pattern, map);
|
||||
end
|
||||
|
||||
-- reverse a utf8 string
|
||||
function this.unicode.reverse(s)
|
||||
-- reverse the individual greater-than-single-byte characters
|
||||
s = s:gsub(pattern, function (c)
|
||||
return #c > 1 and c:reverse()
|
||||
end);
|
||||
|
||||
return s:reverse();
|
||||
end
|
||||
|
||||
-- strip non-ascii characters from a utf8 string
|
||||
function this.unicode.strip(s)
|
||||
return s:gsub(pattern, function(c)
|
||||
return #c > 1 and '';
|
||||
end);
|
||||
end
|
||||
|
||||
-- generator for the above -- to iterate over all utf8 chars
|
||||
function this.unicode.chars(s, no_subs)
|
||||
return coroutine.wrap(function()
|
||||
return unicode_map(s, coroutine.yield, no_subs);
|
||||
end);
|
||||
end
|
||||
|
||||
-- like string.sub() but i, j are utf8 strings
|
||||
-- a utf8-safe string.sub()
|
||||
function this.unicode.sub(str, i, j)
|
||||
if coroutine == nil then
|
||||
return str;
|
||||
end
|
||||
|
||||
local l = utf8.len(str);
|
||||
|
||||
i = unicode_relative_position(i, l);
|
||||
j = j and unicode_relative_position(j, l) or l;
|
||||
|
||||
if i < 1 then
|
||||
i = 1;
|
||||
end
|
||||
|
||||
if j > l then
|
||||
j = l;
|
||||
end
|
||||
|
||||
if i > j then
|
||||
return "";
|
||||
end
|
||||
|
||||
local diff = j - i;
|
||||
local iterator = unicode_chars(str, true);
|
||||
|
||||
-- advance up to i
|
||||
for _ = 1, i - 1 do
|
||||
iterator();
|
||||
end
|
||||
|
||||
local c, b = select(2, iterator());
|
||||
|
||||
-- i and j are the same, single-charaacter sub
|
||||
if diff == 0 then
|
||||
return string.sub(str, b, b + c - 1);
|
||||
end
|
||||
|
||||
i = b;
|
||||
|
||||
-- advance up to j
|
||||
for _ = 1, diff - 1 do
|
||||
iterator();
|
||||
end
|
||||
|
||||
c, b = select(2, iterator());
|
||||
|
||||
return string.sub(str, i, b + c - 1);
|
||||
end
|
||||
|
||||
function this.init_module()
|
||||
end
|
||||
|
||||
table_tostring = this.table.tostring;
|
||||
deep_copy = this.table.deep_copy;
|
||||
merge = this.table.merge;
|
||||
is_empty = this.table.is_empty;
|
||||
unicode_map = this.unicode.map;
|
||||
unicode_relative_position = this.unicode.relative_position;
|
||||
unicode_chars = this.unicode.chars;
|
||||
|
||||
return this;
|
||||
Reference in New Issue
Block a user