Method CreateConfig

src/exec/ar.cpp:41–95

struct CreateConfig {

    CreateConfig(std::filesystem::path path, std::string prefix) : prefix(prefix) {
        // Load JSON
        std::ifstream config_file(path);
        Json::Value config_json;
        config_file >> config_json;
        config_file.close();
        Json::Value::Object config = config_json.get<Json::Value::Object>();

        // prefix
        if(prefix.empty() && config.contains("prefix")){
            this->prefix = config["prefix"].get<std::string>();
        }

        // paths
        if(config.contains("paths")){
            for(Json::Value value : config["paths"].get<Json::Value::Array>()){
                value.visit(overloaded {
                    [](auto&){
                        throw Exception::Exception("invalid path type");
                    },
                    [&](Json::Value::String& path_str){
                        auto parsed = parse_create_path(path_str);
                        if(!std::filesystem::exists(parsed.first)){
                            Exception::Warning(std::string("file ") + parsed.first.string() + " not found, skipped");
                            return;
                        }
                        std::filesystem::path file_path = std::filesystem::canonical(parsed.first);
                        if(paths.contains(file_path)){
                            Exception::Warning(std::string("multiple definitions found for file ") + parsed.first.string());
                        }
                        paths[file_path] = parsed.second.value_or(std::filesystem::relative(file_path));
                    },
                    [&](Json::Value::Object& path_obj){
                        if(!path_obj.contains("file")){
                            throw Exception::Exception("invalid path object");
                        }
                        std::filesystem::path file_path = path_obj["file"].get<std::string>();
                        if(!std::filesystem::exists(file_path)){
                            Exception::Warning(std::string("file ") + file_path.string() + " not found, skipped");
                            return;
                        }
                        std::filesystem::path canon = std::filesystem::canonical(file_path);
                        if(paths.contains(canon)){
                            Exception::Warning(std::string("multiple definitions found for file ") + file_path.string());
                        }
                        if(path_obj.contains("module")){
                            paths[canon] = path_obj["module"].get<std::string>();
                        }else{
                            paths[canon] = std::filesystem::relative(canon);
                        }
                    }
                });
            }
        }
    }

    std::filesystem::path prefix;
    std::map<std::filesystem::path, std::filesystem::path> paths;