rsbin/storage.r

local moduledef = registermodule("rsbin/storage", "src/rsbin/storage.hpp")
include(moduledef, "common/task")
include(moduledef, "common/refobject")
decl(moduledef, {
    rstruct = true,
    structtype = true,
    location = {{"src/rsbin/storage.hpp", 10, 2}},
    attrs = {["r::name"] = {"storagemap"}, ["r::struct"] = false},
    sourcename = "::rsbin::StorageMap",
    luaname = "rsbin.storagemap",
    commonname = "rsbin_storagemap",
    fields = {
        {
    location = {{"src/rsbin/storage.hpp", 12, 3}},
    attrs = {},
            name = {"ptr"},
            interntype = types.pointertype:create(types.scalartype:create(nslookup(moduledef, "::uint8_t"), false), false),
        },
        {
    location = {{"src/rsbin/storage.hpp", 13, 3}},
    attrs = {},
            name = {"length"},
            interntype = types.scalartype:create(nslookup(moduledef, "::uint32_t"), false),
        },
    },
})
decl(moduledef, {
    rclass = true,
    classtype = true,
    location = {{"src/rsbin/storage.hpp", 16, 2}},
    attrs = {["r::class"] = false, ["r::name"] = {"maptask"}},
    base = nslookup(moduledef, "::Task"),
    sourcename = "::rsbin::MapTask",
    luaname = "rsbin.maptask",
    commonname = "rsbin_maptask",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 21, 11}},
    attrs = {["r::method"] = false},
    rettype = types.structtype:create(nslookup(moduledef, "::rsbin::StorageMap"), false),
    argtypes = {
    },
    outerdecl = nslookup(moduledef, "::rsbin::MapTask"),
    sourcename = "::rsbin::MapTask::getmap",
    sourcelocalname = "getmap",
    lualocalname = "getmap",
    commonname = "rsbin_maptask_getmap",
})
decl(moduledef, {
    rclass = true,
    classtype = true,
    location = {{"src/rsbin/storage.hpp", 24, 2}},
    attrs = {["r::class"] = false, ["r::name"] = {"getlimittask"}},
    base = nslookup(moduledef, "::Task"),
    sourcename = "::rsbin::GetLimitTask",
    luaname = "rsbin.getlimittask",
    commonname = "rsbin_getlimittask",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 29, 11}},
    attrs = {["r::method"] = false},
    rettype = types.scalartype:create(nslookup(moduledef, "::uint64_t"), false),
    argtypes = {
    },
    outerdecl = nslookup(moduledef, "::rsbin::GetLimitTask"),
    sourcename = "::rsbin::GetLimitTask::getlimit",
    sourcelocalname = "getlimit",
    lualocalname = "getlimit",
    commonname = "rsbin_getlimittask_getlimit",
})
decl(moduledef, {
    rclass = true,
    classtype = true,
    location = {{"src/rsbin/storage.hpp", 32, 2}},
    attrs = {["r::class"] = false, ["r::name"] = {"storage"}},
    base = nslookup(moduledef, "::RefObject"),
    sourcename = "::rsbin::Storage",
    luaname = "rsbin.storage",
    commonname = "rsbin_storage",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 41, 11}},
    attrs = {["r::method"] = false},
    rettype = types.classreftype:create(nslookup(moduledef, "::rsbin::MapTask"), false, nil),
    argtypes = {
        types.scalartype:create(nslookup(moduledef, "::uint64_t"), false),
        types.scalartype:create(nslookup(moduledef, "::uint32_t"), false),
        types.fundamental:create("bool", false),
        types.fundamental:create("bool", false),
    },
    outerdecl = nslookup(moduledef, "::rsbin::Storage"),
    sourcename = "::rsbin::Storage::startmap",
    sourcelocalname = "startmap",
    lualocalname = "startmap",
    commonname = "rsbin_storage_startmap",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 45, 11}},
    attrs = {["r::method"] = false},
    rettype = types.classreftype:create(nslookup(moduledef, "::rsbin::GetLimitTask"), false, nil),
    argtypes = {
        types.pointertype:create(types.scalartype:create(nslookup(moduledef, "::uint64_t"), false), false),
    },
    outerdecl = nslookup(moduledef, "::rsbin::Storage"),
    sourcename = "::rsbin::Storage::startgetlimit",
    sourcelocalname = "startgetlimit",
    lualocalname = "startgetlimit",
    commonname = "rsbin_storage_startgetlimit",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 47, 11}},
    attrs = {["r::method"] = false},
    rettype = types.classreftype:create(nslookup(moduledef, "::Task"), false, nil),
    argtypes = {
        types.scalartype:create(nslookup(moduledef, "::uint64_t"), false),
    },
    outerdecl = nslookup(moduledef, "::rsbin::Storage"),
    sourcename = "::rsbin::Storage::startsetlimit",
    sourcelocalname = "startsetlimit",
    lualocalname = "startsetlimit",
    commonname = "rsbin_storage_startsetlimit",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 49, 11}},
    attrs = {["r::method"] = false},
    rettype = types.classreftype:create(nslookup(moduledef, "::Task"), false, nil),
    argtypes = {
    },
    outerdecl = nslookup(moduledef, "::rsbin::Storage"),
    sourcename = "::rsbin::Storage::startflush",
    sourcelocalname = "startflush",
    lualocalname = "startflush",
    commonname = "rsbin_storage_startflush",
})
decl(moduledef, {
    rmethod = true,
    location = {{"src/rsbin/storage.hpp", 51, 11}},
    attrs = {["r::method"] = false},
    rettype = types.classreftype:create(nslookup(moduledef, "::Task"), false, nil),
    argtypes = {
    },
    outerdecl = nslookup(moduledef, "::rsbin::Storage"),
    sourcename = "::rsbin::Storage::startclose",
    sourcelocalname = "startclose",
    lualocalname = "startclose",
    commonname = "rsbin_storage_startclose",
})
decl(moduledef, {
    remit = true,
    location = {{"src/rsbin/storage.hpp", 55, 1}},
    payload = "\
\9function rsbin_storage:map(offset, length, flagread, flagwrite)\
\9\9local task = self:startmap(offset, length, flagread, flagwrite)\
\9\9if not task then\
\9\9\9return nil, nil, 0\
\9\9end\
\9\9while not task:poll() do\
\9\9\9coroutine.yield()\
\9\9end\
\9\9local map = task:getmap()\
\9\9if map.ptr == nil or map.length == 0 then\
\9\9\9return task, nil, 0\
\9\9else\
\9\9\9return task, map.ptr, map.length\
\9\9end\
\9end\
\
\9function rsbin_storage:getlimit()\
\9\9local limit = ffi.new('uint64_t[1]')\
\9\9local task = self:startgetlimit(limit)\
\9\9if task then\
\9\9\9while not task:poll() do\
\9\9\9\9coroutine.yield()\
\9\9\9end\
\9\9\9local result = task:getlimit()\
\9\9\9task:release()\
\9\9\9return result\
\9\9else\
\9\9\9return limit[0]\
\9\9end\
\9end\
\
\9function rsbin_storage:setlimit(limit)\
\9\9local task = self:startsetlimit(limit)\
\9\9if task then\
\9\9\9while not task:poll() do\
\9\9\9\9coroutine.yield()\
\9\9\9end\
\9\9\9task:release()\
\9\9end\
\9end\
\
\9function rsbin_storage:flush()\
\9\9local task = self:startflush()\
\9\9if task then\
\9\9\9while not task:poll() do\
\9\9\9\9coroutine.yield()\
\9\9\9end\
\9\9\9task:release()\
\9\9end\
\9end\
\
\9function rsbin_storage:close()\
\9\9local task = self:startclose()\
\9\9if task then\
\9\9\9while not task:poll() do\
\9\9\9\9coroutine.yield()\
\9\9\9end\
\9\9\9task:release()\
\9\9end\
\9end\
",
})