5 Several common useful Lua functions
11 Copyright 2008 Steven Barth <steven@midlink.org>
13 Licensed under the Apache License, Version 2.0 (the "License");
14 you may not use this file except in compliance with the License.
15 You may obtain a copy of the License at
17 http://www.apache.org/licenses/LICENSE-2.0
19 Unless required by applicable law or agreed to in writing, software
20 distributed under the License is distributed on an "AS IS" BASIS,
21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 See the License for the specific language governing permissions and
23 limitations under the License.
27 -- LuCI utility functions.
28 module("luci.util", package.seeall)
31 -- Class helper routines
34 --- Creates a Class object (Python-style object model)
35 -- Creates a new class object which can be instantiated by calling itself.
36 -- Any class functions or shared parameters can be attached to this object.
37 -- Attaching a table to the class object makes this table shared between
38 -- all instances of this class. For object paramters use the __init__ function.
39 -- Classes can inherit member functions and values from a base class.
40 -- Class can be instantiated by calling them. All parameters will be passed
41 -- to the __init__ function of this class - if such a function exists.
42 -- The __init__ function must be used to set any object parameters that are not shared
43 -- with other objects of this class. Any return values will be ignored.
44 -- @param base The base class to inherit from (optional)
45 -- @return A class object
51 local create = function(class, ...)
53 setmetatable(inst, {__index = class})
56 local stat, err = copcall(inst.__init__, inst, ...)
65 local classmeta = {__call = create}
68 classmeta.__index = base
71 setmetatable(class, classmeta)
75 --- Test whether the given object is an instance of the given class.
76 -- @param object Object instance
77 -- @param class Class object to test against
78 -- @return Boolean indicating wheather the object is an instance
81 function instanceof(object, class)
82 local meta = getmetatable(object)
83 while meta and meta.__index do
84 if meta.__index == class then
87 meta = getmetatable(meta.__index)
94 -- Scope manipulation routines
97 --- Resets the scope of f doing a shallow copy of its scope into a new table
98 -- (ToDo: @param and @return)
100 setfenv(f, clone(getfenv(f)))
103 --- Store given object associated with given key in the scope associated with
104 -- the given identifier.
105 -- @param f Value containing the scope identifier
106 -- @param key String value containg the key of the object to store
107 -- @param obj Object to store in the scope
108 -- @return Always nil
109 function extfenv(f, key, obj)
110 local scope = getfenv(f)
114 --- Updates the scope of f with "extscope" (ToDo: docu)
115 function updfenv(f, extscope)
116 update(getfenv(f), extscope)
119 --- Create a new or get an already existing thread local store associated with
120 -- the current active coroutine. A thread local store is private a table object
121 -- whose values can't be accessed from outside of the running coroutine.
122 -- @return Table value representing the corresponding thread local store
123 function threadlocal()
126 local function get(self, key)
127 local c = coroutine.running()
128 local thread = coxpt[c] or c or 0
129 if not rawget(self, thread) then
132 return rawget(self, thread)[key]
135 local function set(self, key, value)
136 local c = coroutine.running()
137 local thread = coxpt[c] or c or 0
138 if not rawget(self, thread) then
139 rawset(self, thread, {})
141 rawget(self, thread)[key] = value
144 setmetatable(tbl, {__index = get, __newindex = set, __mode = "k"})
151 -- Debugging routines
154 --- Write given object to stderr.
155 -- @param obj Value to write to stderr
156 -- @return Boolean indicating wheather the write operation was successful
158 io.stderr:write(tostring(obj) .. "\n")
161 --- Recursively dumps a table to stdout, useful for testing and debugging.
162 -- @param t Table value to dump
163 -- @param i Number of tabs to prepend to each line
164 -- @return Always nil
165 function dumptable(t, i)
167 for k,v in pairs(t) do
168 print(string.rep("\t", i) .. tostring(k), tostring(v))
169 if type(v) == "table" then
177 -- String and data manipulation routines
180 --- Escapes all occurences of the given character in given string.
181 -- @param s String value containing unescaped characters
182 -- @param c String value with character to escape (optional, defaults to "\")
183 -- @return String value with each occurence of character escaped with "\"
184 function escape(s, c)
186 return s:gsub(c, "\\" .. c)
189 --- Create valid XML PCDATA from given string.
190 -- @param value String value containing the data to escape
191 -- @return String value containing the escaped data
192 function pcdata(value)
193 value = value:gsub("&", "&")
194 value = value:gsub('"', """)
195 value = value:gsub("'", "'")
196 value = value:gsub("<", "<")
197 return value:gsub(">", ">")
200 --- Splits given string on a defined seperator sequence and return a table
201 -- containing the resulting substrings. The optional max parameter specifies
202 -- the number of bytes to process, regardless of the actual length of the given
203 -- string. The optional last parameter, regex, sepcifies wheather the separator
204 -- sequence is interpreted as regular expression.
205 -- @param str String value containing the data to split up
206 -- @param pat String with separator pattern (optional, defaults to "\n")
207 -- @param max Num of bytes to process (optional, default is string length)
208 -- @param regexp Boolean indicating wheather to interprete the separator
209 -- pattern as regular expression (optional, default is false)
210 -- @return Table containing the resulting substrings
211 function split(str, pat, max, regex)
231 local s, e = str:find(pat, c, not regex)
233 if s and max < 0 then
234 table.insert(t, str:sub(c))
236 table.insert(t, str:sub(c, s and s - 1))
238 c = e and e + 1 or #str + 1
239 until not s or max < 0
244 --- Remove leading and trailing whitespace from given string value.
245 -- @param str String value containing whitespace padded data
246 -- @return String value with leading and trailing space removed
248 local s = str:gsub("^%s*(.-)%s*$", "%1")
252 --- Parse certain units from the given string and return the canonical integer
253 -- value or 0 if the unit is unknown. Upper- or lowercase is irrelevant.
254 -- Recognized units are:
255 -- o "y" - one year (60*60*24*366)
256 -- o "m" - one month (60*60*24*31)
257 -- o "w" - one week (60*60*24*7)
258 -- o "d" - one day (60*60*24)
259 -- o "h" - one hour (60*60)
260 -- o "min" - one minute (60)
261 -- o "kb" - one kilobyte (1024)
262 -- o "mb" - one megabyte (1024*1024)
263 -- o "gb" - one gigabyte (1024*1024*1024)
264 -- o "kib" - one si kilobyte (1000)
265 -- o "mib" - one si megabyte (1000*1000)
266 -- o "gib" - one si gigabyte (1000*1000*1000)
267 -- @param ustr String containing a numerical value with trailing unit
268 -- @return Number containing the canonical value
269 function parse_units(ustr)
276 y = 60 * 60 * 24 * 366,
277 m = 60 * 60 * 24 * 31,
278 w = 60 * 60 * 24 * 7,
286 gb = 1024 * 1024 * 1024,
288 -- storage sizes (si)
291 gib = 1000 * 1000 * 1000
294 -- parse input string
295 for spec in ustr:lower():gmatch("[0-9%.]+[a-zA-Z]*") do
297 local num = spec:gsub("[^0-9%.]+$","")
298 local spn = spec:gsub("^[0-9%.]+", "")
300 if map[spn] or map[spn:sub(1,1)] then
301 val = val + num * ( map[spn] or map[spn:sub(1,1)] )
311 --- Combines two or more numerically indexed tables into one.
312 -- @param tbl1 Table value to combine
313 -- @param tbl2 Table value to combine
314 -- @param tblN More values to combine
315 -- @return Table value containing all values of given tables
316 function combine(...)
318 for i, a in ipairs(arg) do
319 for j, v in ipairs(a) do
320 table.insert(result, v)
326 --- Checks whether the given table contains the given value.
327 -- @param table Table value
328 -- @param value Value to search within the given table
329 -- @return Boolean indicating wheather the given value occurs within table
330 function contains(table, value)
331 for k, v in pairs(table) do
339 --- Update values in given table with the values from the second given table.
340 -- Both table are - in fact - merged together.
341 -- @param t Table which should be updated
342 -- @param updates Table containing the values to update
343 -- @return Always nil
344 function update(t, updates)
345 for k, v in pairs(updates) do
350 --- Clones the given object and return it's copy.
351 -- @param object Table value to clone
352 -- @param deep Boolean indicating wheather to do recursive cloning
353 -- @return Cloned table value
354 function clone(object, deep)
357 for k, v in pairs(object) do
358 if deep and type(v) == "table" then
364 setmetatable(copy, getmetatable(object))
371 -- Byte code manipulation routines
374 --- Return the current runtime bytecode of the given function. The byte code
375 -- will be stripped before it is returned.
376 -- @param f Function value to return as bytecode
377 -- @return String value containing the bytecode of the given function
378 function get_bytecode(f)
379 local d = string.dump(f)
380 return d and strip_bytecode(d)
383 --- Strips unnescessary lua bytecode from given string. Information like line
384 -- numbers and debugging numbers will be discarded. Original version by
385 -- Peter Cawley (http://lua-users.org/lists/lua-l/2008-02/msg01158.html)
386 -- @param code String value containing the original lua byte code
387 -- @return String value containing the stripped lua byte code
388 function strip_bytecode(code)
389 local version, format, endian, int, size, ins, num, lnum = code:byte(5, 12)
392 subint = function(code, i, l)
395 val = val * 256 + code:byte(i + n - 1)
400 subint = function(code, i, l)
403 val = val * 256 + code:byte(i + n - 1)
410 strip_function = function(code)
411 local count, offset = subint(code, 1, size)
412 local stripped, dirty = string.rep("\0", size), offset + count
413 offset = offset + count + int * 2 + 4
414 offset = offset + int + subint(code, offset, int) * ins
415 count, offset = subint(code, offset, int)
418 t, offset = subint(code, offset, 1)
422 offset = offset + size + subint(code, offset, size)
424 offset = offset + num
425 elseif t == 254 or t == 9 then
426 offset = offset + lnum
429 count, offset = subint(code, offset, int)
430 stripped = stripped .. code:sub(dirty, offset - 1)
432 local proto, off = strip_function(code:sub(offset, -1))
433 stripped, offset = stripped .. proto, offset + off - 1
435 offset = offset + subint(code, offset, int) * int + int
436 count, offset = subint(code, offset, int)
438 offset = offset + subint(code, offset, size) + size + int * 2
440 count, offset = subint(code, offset, int)
442 offset = offset + subint(code, offset, size) + size
444 stripped = stripped .. string.rep("\0", int * 3)
445 return stripped, offset
448 return code:sub(1,12) .. strip_function(code:sub(13,-1))
453 -- Sorting iterator functions
456 function _sortiter( t, f )
459 for k, v in pairs(t) do
460 table.insert( keys, k )
464 local _len = table.getn( keys )
466 table.sort( keys, f )
471 return keys[_pos], t[keys[_pos]]
476 --- Return a key, value iterator which returns the values sorted according to
477 -- the provided callback function.
478 -- @param t The table to iterate
479 -- @param f A callback function to decide the order of elements
480 -- @return Function value containing the corresponding iterator
482 return _sortiter( t, f )
485 --- Return a key, value iterator for the given table.
486 -- The table pairs are sorted by key.
487 -- @param t The table to iterate
488 -- @return Function value containing the corresponding iterator
490 return _sortiter( t )
493 --- Return a key, value iterator for the given table.
494 -- The table pairs are sorted by value.
495 -- @param t The table to iterate
496 -- @return Function value containing the corresponding iterator
498 return _sortiter( t, function (a,b) return t[a] < t[b] end )
503 -- Coroutine safe xpcall and pcall versions modified for Luci
505 -- coxpcall 1.13 - Copyright 2005 - Kepler Project (www.keplerproject.org)
508 local performResume, handleReturnValue
509 local oldpcall, oldxpcall = pcall, xpcall
511 setmetatable(coxpt, {__mode = "kv"})
514 function coxpcall(f, err, ...)
515 local res, co = oldpcall(coroutine.create, f)
518 local newf = function() return f(unpack(params)) end
519 co = coroutine.create(newf)
521 local c = coroutine.running()
522 coxpt[co] = coxpt[c] or c or 0
524 return performResume(err, co, ...)
528 function copcall(f, ...)
529 return coxpcall(f, id, ...)
533 local function id(trace, ...)
538 function handleReturnValue(err, co, status, ...)
540 return false, err(debug.traceback(co, (...)), ...)
542 if coroutine.status(co) == 'suspended' then
543 return performResume(err, co, coroutine.yield(...))
550 function performResume(err, co, ...)
551 return handleReturnValue(err, co, coroutine.resume(co, ...))