Справочник по функциям и классам

[singapur22 14]

Приведу более полное описание класса ini_file():

C++ class ini_file {
    ini_file (string);                                --конструктор/инициализатор объекта класса (путь к конфигурационному файлу .ltx, относительно папки config)

    function line_count("section");                    --возвращает количество параметров в указанной секции, включая материнские
    function r_bool("section", "param");            --считывает значение булевы
    function section_exist("section");                --определяет наличие указанной секции
    function r_float("section", "param");           --считывает числовое значение, с плавающей запятой
    function r_clsid("section", "param");           --возвращает sid класса секции объекта (применим только к параметру "class")
    function r_s32("section", "param");             --считывает целое число. Как положительное, так и отрицательное.
    function r_line("section", index, "default_param", "default_value"); --смотрим ниже
    function r_token("section", "param", const token_list&);  -- смотрим ниже
    function r_vector("section", "param");         --считывает значения трёхмерного вектора. "float, float, float"
    function r_u32("section", "param");             --считывает положительное целое число. Если число отрицательное, то возвращает 4294967296 (2^32)
    function r_string_wq("section", "param");    --считывает строчное значение. Если значение заключено в кавычки, то онные исключаются.
    function r_string("section", "param");          --считывает строчное значение без каких либо изменений.
    function line_exist("section", "param");        --определяет наличие указанного параметра в указанной секции.
};

 

 

Методы r_line() и r_token() требуют отдельного внимания и более полного описания:

Данный метод считывает полную строку (ключ = значение), под указанным индексом. Пример:

local ini = ini_file("blabla.ltx")
local count = ini: line_count("blabla_section")      --получаем количество параметров
for index=0, count-1 do
    local valid, key, value = ini:r_line("blabla_section", index, "default_param", "default_value") --считываем строку под указанным индексом.
    ...
end

Где:

valid = булева, наличие строки под указанным индексом

key = ключ (id, наименование параметра)

value = значение, как строка

"default_param" и "default_value" возвращаются переменным key и value соответственно, если строка под указанным индексом не найдена.

Значение "default_value", так же возвращается переменной value, если параметр key не имеет значения.

Хорошо применим, когда нужно получить все параметры и их значения, указанной секции.

Не стоит пытаться использовать индексы строк, под другими предлогами, так как порядок их при итерации, значительно отличается от порядка прописи параметров в .ltx файле. По какому закону он их перемешивает, одному разрабу известно.

 

 

Метод r_token() возвращает id полученного, текстового значения, из списка token_list. Итак, разберём для начала класс token_list(), чтобы было понятней использование метода r_token().

Данный класс, отвечает за виртуальный список (value = value).

C++ class token_list {
    token_list ();                           --конструктор/инициализатор списка

    function clear();                       --очистить список
    function remove(string);           --удалить ячейку списка по строчному значению.
    function name(number);           --получение строчного значения по id
    function id(string);                    --получение id по строчному значению
    function add(string, number);    --добавление ячейки в список (строчное значение, id)
};

Как видно, данный список не выделяет, кто из них является ключом, а кто значением. Но судя по тому, что удаление производится по строке, и в создании ячейки, первым аргументом является строка, то очевидно, что ключём, всётаки является именно строка, а значением номер id

 

 

Как данный класс применяется в методе r_token()?! Приведу пример:

Создадим в скрипте, список значений:

local t_list = token_list ()
t_list:add("value1", 55)
t_list:add("value2", 77)
t_list:add("value3", 99)

Далее, по созданому списку значений, установим онные в секциях конфигурационных файлов:

[section1]
param = value1
...

[section2]
param = value3
...

[section3]
param = value2
...

Теперь, чтобы получить соответсвующие id, указанным значениям в конфигурационном файле, и потребуется метод r_token():

--// создаём список
local t_list = token_list ()
t_list:add("value1", 55)
t_list:add("value2", 77)
t_list:add("value3", 99)

--//считываем по нему значения
local ini = ini_file("blabla.ltx")
local key = "param"
local id1 = ini:r_token("section1", key, t_list)  --'вернёт значение 55
local id2 = ini:r_token("section2", key, t_list)  --'вернёт значение 99
local id3 = ini:r_token("section3", key, t_list)  --'вернёт значение 77

 

 

[singapur22 14]

malandrinus, Если сами во всём в курсе, то что же сами то не написали полное описание? Ссылку так и держите на пост (меченый(стрелок)), где нормальных описаний, как таковых и нет.

Думаю стоит поправить мой пост, и сделать на него ссыль. Или напиши свой, более точный.

 

Изменено 14 Июля 2011 пользователем singapur22

[singapur22 14]

Всё дело в том, что в зависимости от длины строки, модификатор 's' обрабатывается разными методами. Вот кусок кода, отвечающего за данный модификатор, из исходника метода обработки функции string.format:

case 's': {
          size_t l;
          const char *s = luaL_tolstring(L, arg, &l);
          if (!strchr(form, '.') && l >= 100) {
            /* no precision and string is too long to be formatted;
               keep original string */
            luaL_addvalue(&b);
            break;
          }
          else {
            nb = sprintf(buff, form, s);
            lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */
            break;
          }
        }

[singapur22 14]

Gun12, Хм. А теперь замерь время работы функции unpack() и вычти результат от значения пременной t2. Только в этом случае ты получишь истиное время выполнения функции format.

[singapur22 14]

Gun12, Поэкспериментировал с вашей функцией format. Максимальную скорость получил только в данном случае:

local a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaa" --100 символов
local b = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbb" --100 символов
local c = "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
cccccccccccccccccccccccc" --100 символов
local d = "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
dddddddddddddddddddddddd" --100 символов
local e = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
eeeeeeeeeeeeeeeeeeeeeee" --100 символов

function f(...)
    t = os.clock()
    local q
    for i=1, 100000 do
        q = string.format("%s%s%s%s%s", ...)
    end
    print("format", os.clock() - t)
end

f(a,b,c,d,e)

Причём, обязательно как отдельную функцию, с использованием неявного списка аргументов. (при использовании явных аргументов, время увеличивается)

Но и в этом случае, конкатенация работает немногим быстрее.

 

P.S.

Я бы посоветовал создать тему, непосредственно связанную с языком Lua.

 

Изменено 6 Сентября 2011 пользователем singapur22

[singapur22 14]

И ещё раз о скоростях вычислений в Lua. В частности затронем тему работ с таблицами.

Как не странно, работая с таблицами (особенно с "массивными"), нужно учитывать, как мы её будем итерировать, в том, или ином случае.

Строго-индексированные таблицы, многие предпочитают итерировать посредством функции ipairs(). Данный способ наиьолее удобный, но работает он в два раза медленнее стандартного числового итерирования:

function ft1()
    local t = os.clock()
    for i=0, 100000 do
        for j,v in ipairs(tbl1) do end
    end
    local tr = os.clock() - t
    print("ipairs", tr)
end

function ft2()
    local t = os.clock()
    local c = #tbl1
    local j
    for i=0, 100000 do
        for k=1, c do j = tbl1[k] end
    end
    local tr = os.clock() - t
    print("count", tr)
end

ft1()
ft2()

Результат:

ipairs    0.109
count    0.063

 

Далее. Имеется различие в скорости считывания данных из таблицы, при числовых и строчных ключах. Работая с алгоритмами матриц, обратил внимание, что строчные ключи считываются на ~10...50% быстрее, чем числовые(индексированные), не зависимо от длин имён. По крайней мере, при длинах имён в 1 и 10 символов, различий замечено не было:

local tbl = {[1] = 55, A = 44, Abcdefghij = 99}

function fi()
    local t = os.clock()
    local j
    for i=0, 1000000 do j = tbl[1] end
    local tr = os.clock() - t
    print("indices", tr)
end

function fk()
    local t = os.clock()
    local j
    for i=0, 1000000 do j = tbl.A end
    local tr = os.clock() - t
    print("keys1", tr)
end

function fk2()
    local t = os.clock()
    local j
    for i=0, 1000000 do j = tbl.Abcdefghij end
    local tr = os.clock() - t
    print("keys2", tr)
end

fi()
fk()
fk2()

Результат:

indices    0.078
keys1    0.031
keys2    0.031

Считывание строчных ключей аналогично по скорости, как через точку (tbl.key), так и через квадратные скобки (tbl["key"]).

Изменено 11 Сентября 2011 пользователем singapur22