db_get.lua

   1 QuestHelper_File["db_get.lua"] = "Development Version"
   2 QuestHelper_Loadtime["db_get.lua"] = GetTime()
   3
   4 local dev_mode = (QuestHelper_File["db_get.lua"] == "Development Version")
   5
   6 -- yoink
   7 --[[
   8 local QHDB_temp = QHDB
   9 QHDB = nil
  10 local QHDB = QHDB_temp]]
  11 QuestHelper: Assert(dev_mode or #QHDB == 4)
  12
  13 local weak_v = { __mode = 'v' }
  14 local weak_k = { __mode = 'k' }
  15
  16 local cache = {}
  17
  18 local frequencies = setmetatable({}, weak_k)
  19
  20 -- guhhh just want this to work
  21 local freq_group = setmetatable({}, weak_k)
  22 local freq_id = setmetatable({}, weak_k)
  23
  24 local function DBC_Get(group, id)
  25   if not cache[group] then return end
  26   return cache[group][id]
  27 end
  28
  29 local function DBC_Put(group, id, item)
  30   if not cache[group] then cache[group] = setmetatable({}, weak_v) end
  31   QuestHelper: Assert(not cache[group][id])
  32   cache[group][id] = item
  33
  34   --DB_how_many_are_used()
  35 end
  36
  37 local function mark(tab, tomark)
  38   for k, v in pairs(tab) do
  39     if k ~= "__owner" and type(v) == "table" then
  40       mark(v, tomark)
  41     end
  42   end
  43   tab.__owner = tomark
  44 end
  45
  46 local function read_adaptint(data, offset)
  47   local stx = 0
  48   local acu = 1
  49   while true do
  50     local v = strbyte(data, offset)
  51     QuestHelper: Assert(v, string.format("%d %d", #data, offset))
  52     stx = stx + acu * math.floor(v / 2)
  53     offset = offset + 1
  54     acu = acu * 128
  55     if mod(v, 2) == 0 then break end
  56   end
  57   return stx, offset
  58 end
  59
  60 local function search_index(index, data, item)
  61   --[[Header format:
  62
  63     Itemid (0 for endnode)
  64     Offset
  65     Length
  66     Rightlink]]
  67
  68   local cofs = 1
  69   assert(index and type(index) == "string")
  70   assert(data and type(data) == "string")
  71
  72   while true do
  73     local idx, ofs, len, rlink
  74     idx, cofs = read_adaptint(index, cofs)
  75     if idx == 0 then return end
  76     ofs, cofs = read_adaptint(index, cofs)
  77     len, cofs = read_adaptint(index, cofs)
  78     rlink, cofs = read_adaptint(index, cofs)
  79
  80     if idx == item then
  81       return strsub(data, ofs, ofs + len)
  82     end
  83
  84     if idx < item then cofs = cofs + rlink end
  85   end
  86 end
  87
  88 local initted = false
  89 function DB_Init()
  90   QuestHelper: Assert(not initted)
  91   for _, db in ipairs(QHDB) do
  92     for _, v in pairs(db) do
  93       --print("db", not not v.__dictionary, not not v.__tokens)
  94       if v.__dictionary and v.__tokens then
  95         local redictix = v.__dictionary
  96         if not redictix:find("\"") then redictix = redictix .. "\"" end
  97         if not redictix:find(",") then redictix = redictix .. "," end
  98         if not redictix:find("\\") then redictix = redictix .. "\\" end
  99         local tokens = loadstring("return {" .. QH_LZW_Decompress_Dicts_Arghhacky(v.__tokens, redictix) .. "}")()
 100         QuestHelper: Assert(tokens)
 101
 102         local _, _, prep = QH_LZW_Prepare_Arghhacky(v.__dictionary, tokens)
 103         QuestHelper: Assert(prep)
 104
 105         QuestHelper: Assert(type(prep) == "table")
 106
 107         v.__tokens = prep
 108       end
 109     end
 110   end
 111   initted = true
 112 end
 113
 114 function DB_Ready()
 115   return initted
 116 end
 117
 118 function DB_GetItem(group, id, silent, register)
 119   QuestHelper: Assert(initted)
 120
 121   QuestHelper: Assert(group, string.format("%s %s", tostring(group), tostring(id)))
 122   QuestHelper: Assert(id, string.format("%s %s", tostring(group), tostring(id)))
 123   local ite = DBC_Get(group, id)
 124   if not ite then
 125     if type(id) == "string" then QuestHelper: Assert(not id:match("__.*")) end
 126
 127     --QuestHelper:TextOut(string.format("%s %d", group, id))
 128
 129     for _, db in ipairs(QHDB) do
 130       --print(db, db[group], db[group] and db[group][id], type(group), type(id))
 131       if db[group] then
 132         if not ite then ite = QuestHelper:CreateTable("db") end
 133
 134         local dat
 135         if db[group][id] then
 136           dat = db[group][id]
 137         end
 138
 139         --print(not dat, type(id), id, not not db[group].__serialize_index, not not db[group].__serialize_index)
 140         if not dat and type(id) == "number" and id > 0 and db[group].__serialize_index and db[group].__serialize_data then
 141           dat = search_index(db[group].__serialize_index, db[group].__serialize_data, id)
 142         end
 143
 144         if dat then
 145           local srctab
 146
 147           if type(dat) == "string" then
 148             QuestHelper: Assert(db[group].__tokens == nil or type(db[group].__tokens) == "table")
 149             srctab = loadstring("return {" .. QH_LZW_Decompress_Dicts_Prepared_Arghhacky(dat, db[group].__dictionary, nil, db[group].__tokens) .. "}")()
 150           elseif type(dat) == "table" then
 151             srctab = dat
 152           else
 153             QuestHelper: Assert()
 154           end
 155
 156           for k, v in pairs(srctab) do
 157             QuestHelper: Assert(not ite[k] or k == "used")
 158             ite[k] = v
 159           end
 160         end
 161       end
 162     end
 163     --print("dbe", ite)
 164
 165     if ite then
 166       --print("marking", group, id, silent, register)
 167       mark(ite, ite)
 168       --print("done marking")
 169
 170       DBC_Put(group, id, ite)
 171
 172       freq_group[ite] = group
 173       freq_id[ite] = id
 174     else
 175       if not silent then
 176         QuestHelper:TextOut(string.format("Tried to get %s/%s, failed", tostring(group), tostring(id)))
 177       end
 178     end
 179   end
 180
 181   if ite then
 182     frequencies[ite] = (frequencies[ite] or 0) + (register and 1 or 1000000000) -- effectively infinity
 183   end
 184
 185   return ite
 186 end
 187
 188 local function incinerate(ite, crunchy)
 189   if dev_mode then return end -- wellllp
 190
 191   if not crunchy[ite] then
 192     crunchy[ite] = true
 193
 194     for k, v in pairs(ite) do
 195       if type(k) == "table" then incinerate(k, crunchy) end
 196       if type(v) == "table" then incinerate(v, crunchy) end
 197     end
 198   end
 199 end
 200
 201 function DB_ReleaseItem(ite)
 202   QuestHelper: Assert(ite)
 203   frequencies[ite] = frequencies[ite] - 1
 204
 205   if frequencies[ite] == 0 then
 206     --print("incinerating", freq_group[ite], freq_id[ite])
 207     cache[freq_group[ite]][freq_id[ite]] = nil
 208     freq_group[ite] = nil
 209     freq_id[ite] = nil
 210
 211     local incin = QuestHelper:CreateTable("incinerate")
 212     incinerate(ite, incin)
 213     for k, _ in pairs(incin) do
 214       QuestHelper:ReleaseTable(k)
 215     end -- burn baby burn
 216     QuestHelper:ReleaseTable(incin)
 217   end
 218 end
 219
 220 function DB_ListItems(group)
 221   local tab = {}
 222   for _, db in ipairs(QHDB) do
 223     if db[group] then
 224       QuestHelper: Assert(not db.__serialize_index and not db.__serialize_data)
 225       for k, _ in pairs(db[group]) do
 226         if type(k) ~= "string" or not k:match("__.*") then
 227           tab[k] = true
 228         end
 229       end
 230     end
 231   end
 232
 233   local rv = {}
 234   for k, _ in pairs(tab) do
 235     table.insert(rv, k)
 236   end
 237
 238   return rv
 239 end
 240
 241 function DB_how_many_are_used()
 242   local count = 0
 243   for k, v in pairs(cache) do
 244     for k2, v2 in pairs(v) do
 245       count = count + 1
 246     end
 247   end
 248   print(count)
 249 end
 250
 251 function DB_DumpItems()
 252   local dt = {}
 253   for k, v in pairs(freq_group) do
 254     dt[string.format("%s/%s", freq_group[k], tostring(freq_id[k]))] = true
 255   end
 256   return dt
 257 end