xmake.lua

set_project("cpp-toolbox")
set_version("0.1.0")
set_description("A modular C++ toolbox")
set_xmakever("2.7.0")
set_languages("c++17")

local function require_condition(condition, message, ...)
    if not condition then
        print("error: " .. string.format(message, ...))
        local invalid_configuration = nil
        invalid_configuration()
    end
    return condition
end

option("modules")
    set_default("all")
    set_showmenu(true)
    set_description("Comma separated module roots")
option_end()

option("kind")
    set_default("static")
    set_values("static", "shared")
    set_showmenu(true)
    set_description("Library kind")
option_end()

includes("xmake/flags.lua")

local function split(value, separator)
    local result = {}
    if value == nil or value == "" then return result end
    for item in string.gmatch(value, "[^" .. separator .. "]+") do
        table.insert(result, item)
    end
    return result
end

-- xmake 3 sandbox hides Lua file I/O APIs. Keep this table synchronized with
-- modules/modules.manifest; CMake remains manifest-driven and validates it.
local modules = {
    core = {kind = "interface", deps = {}, packages = {}, sources = {}},
    data = {kind = "interface", deps = {"core"}, packages = {}, sources = {}},
    math = {kind = "interface", deps = {"core"}, packages = {"eigen"}, sources = {}},
    runtime = {kind = "compiled", deps = {"core"}, packages = {"concurrentqueue"}, sources = {"env.cpp", "signal_shutdown.cpp", "stacktrace.cpp", "thread_info.cpp", "thread_pool.cpp", "thread_pool_singleton.cpp", "timer.cpp", "work_stealing_thread_pool.cpp"}},
    containers = {kind = "compiled", deps = {"core", "runtime"}, packages = {"concurrentqueue"}, sources = {"string.cpp"}},
    logging = {kind = "compiled", deps = {"runtime"}, packages = {}, sources = {"thread_logger.cpp", "backend.cpp", "logger.cpp", "level.cpp", "console_sink.cpp", "memory_sink.cpp", "pattern_formatter.cpp", "file_sink.cpp", "rotating_file_sink.cpp", "field.cpp", "context.cpp", "json_formatter.cpp", "json_file_sink.cpp"}},
    functional = {kind = "compiled", deps = {"core"}, packages = {}, sources = {"functional.cpp"}},
    algorithms = {kind = "compiled", deps = {"core", "containers", "functional", "math"}, packages = {}, sources = {"algorithms.cpp"}},
    geometry = {kind = "compiled", deps = {"core", "data", "math"}, packages = {}, sources = {"point.cpp"}},
    geometry_algorithms = {kind = "compiled", deps = {"geometry", "runtime", "concurrency"}, packages = {"eigen"}, sources = {"minmax.cpp"}},
    metrics = {kind = "interface", deps = {"core", "geometry", "math"}, packages = {"eigen"}, sources = {}},
    filesystem = {kind = "compiled", deps = {"core"}, packages = {}, sources = {"file.cpp", "memory_mapped_file.cpp"}},
    utils = {kind = "compiled", deps = {"core", "runtime", "filesystem", "logging"}, packages = {}, sources = {"click.cpp", "ini_config.cpp", "plot.cpp", "print.cpp", "random.cpp", "timer.cpp"}},
    io_formats = {kind = "compiled", deps = {"data", "geometry", "filesystem", "containers", "logging"}, packages = {}, sources = {"pcd.cpp", "kitti.cpp"}},
    io_datasets = {kind = "compiled", deps = {"io_formats", "filesystem", "logging", "runtime"}, packages = {}, sources = {"kitti_pcd.cpp"}},
    concurrency = {kind = "interface", deps = {"runtime"}, packages = {}, sources = {}},
    pcl = {kind = "interface", deps = {"geometry", "geometry_algorithms", "metrics", "concurrency", "logging", "math"}, packages = {"eigen", "nanoflann"}, sources = {}}
}
local module_order = {"core", "data", "math", "runtime", "containers", "logging", "functional", "algorithms", "geometry", "geometry_algorithms", "metrics", "filesystem", "utils", "io_formats", "io_datasets", "concurrency", "pcl"}

local requested = split(get_config("modules") or "all", ",")
require_condition(#requested > 0, "modules cannot be empty")
local roots = {}
if #requested == 1 and requested[1] == "all" then
    roots = module_order
else
    for _, name in ipairs(requested) do
        require_condition(name ~= "all", "all cannot be combined with explicit modules")
        require_condition(modules[name], "unknown module: " .. name)
        table.insert(roots, name)
    end
end

local selected = {}
local visiting = {}
local function visit(name)
    require_condition(modules[name], "unknown module: " .. name)
    require_condition(not visiting[name], "module dependency cycle at: " .. name)
    if selected[name] then return end
    visiting[name] = true
    for _, dep in ipairs(modules[name].deps) do
        if dep ~= "" then visit(dep) end
    end
    visiting[name] = nil
    selected[name] = true
end
for _, root in ipairs(roots) do visit(root) end

local required_packages = {}
for name, _ in pairs(selected) do
    for _, package_name in ipairs(modules[name].packages) do
        required_packages[package_name] = true
    end
end
if required_packages.tbb then add_requires("tbb", {optional = true}) end

local function add_external_packages(package_names)
    for _, package_name in ipairs(package_names) do
        if package_name == "concurrentqueue" then
            add_includedirs("deps/concurrentqueue", {public = true})
        elseif package_name == "tbb" then
            add_packages("tbb")
        elseif package_name == "eigen" then
            add_includedirs("deps/eigen", {public = true})
        elseif package_name == "nanoflann" then
            add_includedirs("deps/nanoflann", {public = true})
        end
    end
end

for _, name in ipairs(module_order) do
    if selected[name] then
        local spec = modules[name]
        local target_name = "cpp-toolbox-" .. name
        target(target_name)
        if spec.kind == "interface" then
            set_kind("headeronly")
        else
            local library_kind = get_config("kind") or "static"
            set_kind(library_kind)
            if library_kind == "shared" then
                add_defines("CPP_TOOLBOX_EXPORTS")
                add_defines("CPP_TOOLBOX_SHARED_DEFINE", {public = true})
            else
                add_defines("CPP_TOOLBOX_STATIC_DEFINE")
            end
            for _, source in ipairs(spec.sources) do
                if source ~= "" then
        require_condition(os.isfile(path.join("src/modules", name, "src", source)),
                        "missing source for " .. name .. ": " .. source)
                    add_files(path.join("src/modules", name, "src", source))
                end
            end
            add_syslinks(is_plat("windows") and "kernel32" or "pthread")
        end
        add_includedirs(path.join("src/modules", name, "include"), {public = true})
        for _, dep in ipairs(spec.deps) do
            if dep ~= "" then add_deps("cpp-toolbox-" .. dep) end
        end
        add_external_packages(spec.packages)
        set_policy("build.optimization.lto", true)
    end
end

print("cpp-toolbox modules: %s", table.concat(roots, ","))