if opts.recursive then
dep, re = e2tool.dlist_recursive(resultname)
else
- dep, re = result.results[resultname]:depends_list():totable_sorted()
+ dep, re = result.results[resultname]:depends_list():totable()
end
if not dep then
error(re)
e2lib.logf(3, "is regarded as result: %s", srcresname)
local res = result.results[srcresname]
- for sourcename in res:sources_list():iter_sorted() do
+ for sourcename in res:sources_list():iter() do
sel[sourcename] = true
end
elseif opts.result then
for _, resultname in pairs(results) do
local res = result.results[resultname]
- for sourcename in res:sources_list():iter_sorted() do
+ for sourcename in res:sources_list():iter() do
if not yet[sourcename] then
table.insert(sources, sourcename)
yet[sourcename] = true
console.infof("digraph \"%s\" {\n", project.name())
for _, r in pairs(results) do
local res = result.results[r]
- local deps, re = res:depends_list():totable_sorted()
+ local deps, re = res:depends_list():totable()
if not deps then
error(re)
end
console.infof(" \"%s\"\n", r)
end
if opts["dot-sources"] then
- for src in res:sources_list():iter_sorted() do
+ for src in res:sources_list():iter() do
if opts.swap then
console.infof(" \"%s-src\" %s \"%s\"\n", src, arrow, r)
else
end
local grp, path
- for cgrpnm in res:chroot_list():iter_sorted() do
+ for cgrpnm in res:chroot_list():iter() do
grp = chroot.groups_byname[cgrpnm]
for f in grp:file_iter() do
info = e2tool.info()
- for dependsname in dependslist:iter_sorted() do
+ for dependsname in dependslist:iter() do
dep = result.results[dependsname]
destdir = e2lib.join(res:build_config().T, "dep", dep:get_name())
bc = res:build_config()
info = e2tool.info()
- for sourcename in res:sources_list():iter_sorted() do
+ for sourcename in res:sources_list():iter() do
e = err.new("installing source failed: %s", sourcename)
destdir = e2lib.join(bc.T, "build")
deps = result.results[resultname]:depends_list()
- for d in deps:iter_sorted() do
+ for d in deps:iter() do
rc, re = visit(d)
if not rc then
return false, re
return true
end
- for resultname in depends:iter_sorted() do
+ for resultname in depends:iter() do
rc, re = visit(resultname)
if not rc then
return false, re
function result.result_class:post_initialize()
local e
- for depname in self:depends_list():iter_sorted() do
+ for depname in self:depends_list():iter() do
if not result.results[depname] then
e = e or err.new("in result %s:", self:get_name())
e:append("dependency does not exist: %s", depname)
e:merge(projenv.get_global_env(), false)
-- Sources env
- for sourcename in self._sources_list:iter_sorted() do
+ for sourcename in self._sources_list:iter() do
local src = source.sources[sourcename]
e:merge(src:get_env(), true)
end
hash.hash_append(hc, self:get_type())
-- sources
- for sourcename in self:sources_list():iter_sorted() do
+ for sourcename in self:sources_list():iter() do
local src, sourceset
src = source.sources[sourcename]
end
-- chroot
- for groupname in self:chroot_list():iter_sorted() do
+ for groupname in self:chroot_list():iter() do
id, re = chroot.groups_byname[groupname]:chrootgroupid(info)
if not id then
return false, e:cat(re)
-- depends
- for depname in self:depends_list():iter_sorted() do
+ for depname in self:depends_list():iter() do
id, re = result.results[depname]:buildid()
if not id then
return false, re
local e2lib = require("e2lib")
local strict = require("strict")
--- TODO: remove _sorted from method names,
--- insertion order methods were and should not be used
-
--- String list class that keeps entries in sorted order
-- while ignoring duplicate entries.
-- Trying to use string list with anything but strings throws an exception.
--- Iterate through the string list in alphabetical order.
-- @return Iterator function.
-function sl.sl:iter_sorted()
+function sl.sl:iter()
local t = {}
local i = 0
--- Concatenate the string list in alphabetical order.
-- @param sep Separator, defaults to empty string.
-- @return Concatenated string.
-function sl.sl:concat_sorted(sep)
+function sl.sl:concat(sep)
assert(sep == nil or type(sep) == "string")
local first = true
local cat = ""
sep = sep or ""
- for e in self:iter_sorted() do
+ for e in self:iter() do
if first then
cat = e
first = false
--- Return string list entries as an array.
-- @return Sorted array.
-function sl.sl:totable_sorted()
+function sl.sl:totable()
local t = {}
self:_sort_if_needed()
for _,v in ipairs(self._list) do
-- vectors, variadic functions, etc.
-- @return All entries as individual return values, in sorted order.
function sl.sl:unpack()
- return unpack(self:totable_sorted())
+ return unpack(self:totable())
end
return strict.lock(sl)
end
cp_depends:insert_table(rc)
- for depname in cp_depends:iter_sorted() do
+ for depname in cp_depends:iter() do
local dep = result.results[depname]
if dep:get_type() ~= "result" then
cp_sources:insert_sl(dep:sources_list())
end
- for sourcename in cp_sources:iter_sorted() do
+ for sourcename in cp_sources:iter() do
local src = source.sources[sourcename]
cp_licences:insert_sl(src:get_licences())
end
-- generate build driver file for each result
-- project/chroot/<group>/<files>
- for g in cp_chroot:iter_sorted() do
+ for g in cp_chroot:iter() do
e2lib.logf(3, "chroot group: %s", g)
local grp = chroot.groups_byname[g]
local destdir = e2lib.join(bc.T, "project/chroot", g)
end
-- project/licences/<licence>/<files>
- for licname in cp_licences:iter_sorted() do
+ for licname in cp_licences:iter() do
local lic = licence.licences[licname]
e2lib.logf(3, "licence: %s", lic:get_name())
local destdir =
end
-- project/results/<res>/<files>
- for depname in cp_depends:iter_sorted() do
+ for depname in cp_depends:iter() do
e2lib.logf(3, "result: %s", depname)
local dep = result.results[depname]
local depbc = dep:build_config()
-- generate config
out = {
string.format("### generated by e2factory for result %s ###\n", depname),
- string.format("CHROOT='%s'\n", dep:chroot_list():concat_sorted(" ")),
- string.format("DEPEND='%s'\n", dep:depends_list():concat_sorted(" ")),
- string.format("SOURCE='%s'\n", dep:sources_list():concat_sorted(" ")),
+ string.format("CHROOT='%s'\n", dep:chroot_list():concat(" ")),
+ string.format("DEPEND='%s'\n", dep:depends_list():concat(" ")),
+ string.format("SOURCE='%s'\n", dep:sources_list():concat(" ")),
}
local config = e2lib.join(destdir, "config")
end
end
- for sourcename in cp_sources:iter_sorted() do
+ for sourcename in cp_sources:iter() do
e2lib.logf(3, "source: %s", sourcename)
local destdir = e2lib.join(bc.T, "project",
e2tool.sourcedir(sourcename))
-- write topologically sorted list of result
local destdir = e2lib.join(bc.T, "project")
local tsorted_results, re =
- e2tool.dlist_recursive(cp_depends:totable_sorted())
+ e2tool.dlist_recursive(cp_depends:totable())
if not tsorted_results then
return false, e:cat(re)
end
hash.hash_append(hc, self._type)
hash.hash_append(hc, self._env:id())
licences = self:get_licences()
- for licencename in licences:iter_sorted() do
+ for licencename in licences:iter() do
lid, re = licence.licences[licencename]:licenceid(info)
if not lid then
return false, re
table.insert(d, string.format("working = %s", self._working))
licences = self:get_licences()
- for licencename in licences:iter_sorted() do
+ for licencename in licences:iter() do
table.insert(d, string.format("licence = %s", licencename))
end
local destdir = string.format("%s/licences", directory)
local fname = string.format("%s/%s.licences", destdir, archive)
local licenses = src:get_licences()
- local licence_list = licenses:concat_sorted("\n").."\n"
+ local licence_list = licenses:concat("\n").."\n"
rc, re = e2lib.mkdir_recursive(destdir)
if not rc then
hash.hash_append(hc, self._env:id())
-- all licences
- for licencename in self:get_licences():iter_sorted() do
+ for licencename in self:get_licences():iter() do
local lid, re = licence.licences[licencename]:licenceid(info)
if not lid then
return false, re
hash.hash_append(hc, tostring(f.copy))
-- per file licence list
- for licencename in f.licences:iter_sorted() do
+ for licencename in f.licences:iter() do
local lid, re = licence.licences[licencename]:licenceid(info)
if not lid then
return false, re
d = {}
table.insert(d, string.format("type = %s", self:get_type()))
table.insert(d, string.format("licences = %s",
- self:get_licences():concat_sorted(" ")))
+ self:get_licences():concat(" ")))
for f in self:file_iter() do
s = string.format("file = %s:%s", f.server, f.location)
table.insert(d, s)
table.insert(d, string.format("licences = %s",
- f.licences:concat_sorted(" ")))
+ f.licences:concat(" ")))
end
if self._sourceid then
local destdir = string.format("%s/licences", directory)
local fname = string.format("%s/%s.licences", destdir,
e2lib.basename(file.location))
- local licence_list = file.licences:concat_sorted("\n") .. "\n"
+ local licence_list = file.licences:concat("\n") .. "\n"
rc, re = e2lib.mkdir_recursive(destdir)
if not rc then
return false, e:cat(re)
hash.hash_append(hc, self._env:id())
licences = self:get_licences()
- for licencename in licences:iter_sorted() do
+ for licencename in licences:iter() do
local lid, re = licence.licences[licencename]:licenceid(info)
if not lid then
return false, re
table.insert(d, string.format("working = %s", self._working))
licences = self:get_licences()
- for licencename in licences:iter_sorted() do
+ for licencename in licences:iter() do
table.insert(d, string.format("licence = %s", licencename))
end
local destdir = e2lib.join(directory, "licences")
local fname = string.format("%s/%s.licences", destdir, archive)
local licences = src:get_licences()
- local licence_list = licences:concat_sorted("\n") .. "\n"
+ local licence_list = licences:concat("\n") .. "\n"
rc, re = e2lib.mkdir_recursive(destdir)
if not rc then
return false, e:cat(re)
assert(type(info) == "table")
licences = self:get_licences()
- for licencename in licences:iter_sorted() do
+ for licencename in licences:iter() do
lid, re = licence.licences[licencename]:licenceid(info)
if not lid then
return false, re
table.insert(d, string.format("working = %s", self._working))
licences = self:get_licences()
- for licencename in licences:iter_sorted() do
+ for licencename in licences:iter() do
table.insert(d, string.format("licence = %s", licencename))
end
local destdir = e2lib.join(directory, "licences")
local fname = string.format("%s/%s.licences", destdir, archive)
local licences = src:get_licences()
- local licence_list = licences:concat_sorted("\n") .. "\n"
+ local licence_list = licences:concat("\n") .. "\n"
rc, re = e2lib.mkdir_recursive(destdir)
if not rc then
return false, e:cat(re)