using parent_t = std::pair<const char*, T*>;

nvp(const char* name, T& value) :

parent_t{name, &value}

{}

//! Store handler function pointer and help message for commands

struct Command {

using handler_t = command_result(*)(color_ostream&,std::vector<std::string>&);

Command(handler_t handler) :

handler_(handler)

{}

command_result operator()(color_ostream& out,

std::vector<std::string>& parameters) const noexcept

{

return handler_(out, parameters);

}

handler_t handler() const noexcept

{ return handler_; }

private:

handler_t handler_;

};

using dispatch_t = const std::map<std::string, Command>;

//! Name to handler function and help message mapping

static dispatch_t dispatch;

static constexpr auto regex_opt = std::regex::icase | std::regex::optimize | std::regex::nosubs;

LevelName(const std::string& name) :

name_{name},

match_{name, regex_opt}

{}

bool match(const std::string& value) const

{

return std::regex_match(value, match_);

}

operator const std::string&() const noexcept

{

return name_;

}

const std::string& str() const noexcept

{

return name_;

}

template<typename T>

std::string operator+(const T& v) const

{

return name_ + v;

}

std::string name_;

std::regex match_;

explicit Filter(DebugCategory::level level,

const std::string& categoryText,

const std::regex& category,

const std::string& pluginText,

const std::regex& plugin,

bool persistent = true,

bool enabled = true) noexcept;

explicit Filter(DebugCategory::level level,

const std::string& categoryText,

const std::string& pluginText,

bool persistent = true,

bool enabled = true);

explicit Filter() = default;

//! Apply the filter to a category if regex's match

void apply(DFHack::DebugCategory& cat) noexcept;

//! Apply the filter to a category that has been already matched

bool applyAgain(DFHack::DebugCategory& cat) const noexcept;

//! Remove the category from matching count if regex's match

//! \return true if regex's matched

bool remove(const DFHack::DebugCategory& cat) noexcept;

//! Query if filter is enabled

bool enabled() const noexcept {return enabled_;}

//! Set the enable status of filter

void enabled(bool enable) noexcept;

//! Query if filter is persistent

bool persistent() const noexcept {return persistent_;}

//! Query if the filter level

bool level() const noexcept {return level_;}

//! Query number of matching categories

size_t matches() const noexcept {return matches_;}

//! Add matches count for the initial category filter matching

void addMatch() noexcept {++matches_;}

//! Return the category filter text

const std::string& categoryText() const noexcept {return categoryText_;}

//! Return the plugin filter text

const std::string& pluginText() const noexcept {return pluginText_;}

//! Load Filter from configuration file. Second parameter would be version

//! number if format changes in future to include more fields. Then new

//! fields would have to be loaded conditionally

void load(JsonArchive& ar, const unsigned int)

{

ar >> NVP(categoryText_)

>> NVP(pluginText_)

>> NVP(enabled_)

>> NVP(level_);

TRACE(filter) << "Loading filter cat: " << categoryText_

<< " plug: " << pluginText_

<< " ena " << enabled_

<< " level: " << level_

<< std::endl;

persistent_ = true;

matches_ = 0;

category_ = std::regex{categoryText_};

plugin_ = std::regex{pluginText_};

}

//! Save the Filter to json configuration file

void save(JsonArchive& ar, const unsigned int) const

{

ar << NVP(categoryText_)

<< NVP(pluginText_)

<< NVP(enabled_)

<< NVP(level_);

}

std::regex category_;

std::regex plugin_;

DebugCategory::level level_{DebugCategory::level::LTRACE};

size_t matches_{0};

bool persistent_{false};

bool enabled_{false};

std::string categoryText_;

std::string pluginText_;

const std::string& categoryText,

const std::regex& category,

const std::string& pluginText,

const std::regex& plugin,

bool persistent,

bool enabled) noexcept :

category_{category},

plugin_{plugin},

level_{level},

matches_{0},

persistent_{persistent},

enabled_{enabled},

categoryText_{categoryText},

pluginText_{pluginText}

const std::string& categoryText,

const std::string& pluginText,

bool persistent,

bool enabled) :

Filter{

level,

categoryText,

std::regex{categoryText, defaultRegex},

pluginText,

std::regex{pluginText, defaultRegex},

persistent,

enabled,

}

{

if (enable == enabled_)

return;

enabled_ = enable;

{

if (!enabled_)

return false;

if (!std::regex_search(cat.category(), category_))

return false;

if (!std::regex_search(cat.category(), plugin_))

return false;

TRACE(filter) << "apply " << cat.plugin() << ':' << cat.category() << " matches '"

<< pluginText() << "' '" << categoryText() << '\'' << std::endl;

cat.allowed(level_);

return true;

{

if (applyAgain(cat))

++matches_;

{

if (!enabled_)

return false;

if (!std::regex_search(cat.category(), category_))

return false;

if (!std::regex_search(cat.category(), plugin_))

return false;

TRACE(filter) << "remove " << cat.plugin() << ':' << cat.category() << " matches '"

<< pluginText() << "' '" << categoryText() << std::endl;

--matches_;

return true;

{

using parent_t = std::map<size_t, Filter>;

//! Current configuration version implemented by the code

constexpr static Json::UInt configVersion{1};

//! Path to the configuration file

constexpr static const char* configPath{"dfhack-config/runtime-debug.json"};

//! Get reference to the singleton

static FilterManager& getInstance() noexcept

{

static FilterManager instance;

return instance;

}

//! Add a new filter which gets automatically a new id

template<typename... Args>

std::pair<iterator,bool> emplaceNew( Args&&... args ) {

return emplace(std::piecewise_construct,

std::forward_as_tuple(nextId_++),

std::forward_as_tuple(std::forward<Args>(args)...));

}

//! Load state from the configuration file

DFHack::command_result loadConfig(DFHack::color_ostream& out) noexcept;

//! Save state to the configuration file

DFHack::command_result saveConfig(DFHack::color_ostream& out) const noexcept;

//! Connect FilterManager to DFHack::DebugManager::categorySignal

void connectTo(DebugManager::categorySignal_t& signal) noexcept;

//! Temporary block DFHack::DebugManager::categorySignal

DebugManager::categorySignal_t::BlockGuard blockSlot() noexcept;

~FilterManager();

FilterManager(const FilterManager&) = delete;

FilterManager(FilterManager&&) = delete;

FilterManager& operator=(FilterManager) = delete;

FilterManager& operator=(FilterManager&&) = delete;

void load(JsonArchive& ar)

{

Json::UInt version = -1;

ar >> serialization::make_nvp("configVersion", version);

if (version > configVersion) {

std::stringstream ss;

ss << "The saved config version ("

<< version

<< ") is newer than code supported version ("

<< configVersion

<< ")";

throw std::runtime_error{ss.str()};

}

ar >> NVP(nextId_);

JsonArchive& children = ar["filters"];

for (auto iter = children.begin(); iter != children.end(); ++iter) {

Filter child;

child.load(*iter, version);

std::stringstream ss(iter.name());

size_t id;

ss >> id;

insert(std::make_pair(id, child));

}

}

void save(JsonArchive& ar) const

{

JsonArchive children{Json::objectValue};

for (const auto& filterPair: *this) {

if (!filterPair.second.persistent())

continue;

std::stringstream ss;

ss << filterPair.first;

filterPair.second.save(children[ss.str()], configVersion);

}

auto configVersion = FilterManager::configVersion;

ar << NVP(configVersion)

<< NVP(nextId_);

ar["filters"] = children;

}

FilterManager() = default;

//! The next integer to use as id to have each with unique number

Json::UInt64 nextId_;

DebugManager::categorySignal_t::Connection connection_;

{

nextId_ = 1;

if (!Filesystem::isfile(configPath))

return CR_OK;

try {

DEBUG(command, out) << "Load config from '" << configPath << "'" << std::endl;

JsonArchive archive;

std::ifstream ifs(configPath);

if (!ifs.good())

throw std::runtime_error{"Failed to open configuration file for reading"};

ifs >> archive;

load(archive);

} catch(std::exception& e) {

ERR(command, out) << "Serializing filters from '" << configPath << "' failed: "

<< e.what() << std::endl;

return CR_FAILURE;

}

return CR_OK;

{

try {

DEBUG(command, out) << "Save config to '" << configPath << "'" << std::endl;

JsonArchive archive;

save(archive);

std::ofstream ofs(configPath);

if (!ofs.good())

throw std::runtime_error{"Failed to open configuration file for writing"};

ofs << archive;

} catch(std::exception & e) {

ERR(command, out) << "Serializing filters to '" << configPath << "' failed: "

<< e.what() << std::endl;

return CR_FAILURE;

}

return CR_OK;

{

connection_ = signal.connect(

[this](DebugManager::signalType t, DebugCategory& cat) {

TRACE(filter) << "sig type: " << t << ' '

<< cat.plugin() << ':'

<< cat.category() << std::endl;

switch (t) {

case DebugManager::CAT_ADD:

for (auto& filterPair: *this)

filterPair.second.apply(cat);

break;

case DebugManager::CAT_REMOVE:

for (auto& filterPair: *this)

filterPair.second.remove(cat);

break;

case DebugManager::CAT_MODIFIED:

break;

}

});

{

TRACE(filter) << "Temporary disable FilterManager::connection_" << std::endl;

return {connection_};

color_ostream& out,

std::vector<std::string>& parameters,

size_t pos)

{

if (parameters.size() <= pos)

return CR_OK;

try {

std::regex temp{parameters[pos], defaultRegex};

target = std::move(temp);

} catch(std::regex_error & e) {

ERR(command,out) << "Failed to parse regular expression '"

<< parameters[pos] << "'\n";

ERR(command,out) << "Parser message: " << e.what() << std::endl;

return CR_WRONG_USAGE;

}

return CR_OK;

std::vector<std::string>& parameters,

size_t pos,

Callable1 header,

Callable2 categoryMatch,

Callable3 listComplete)

{

std::regex pluginRegex{".", defaultRegex};

std::regex categoryRegex{".", defaultRegex};

command_result rv = CR_OK;

DEBUG(command,out) << "applying category filters '"

<< (parameters.size() >= pos + 1 ? parameters[pos] : "")

<< "' and plugin filter '"

<< (parameters.size() >= pos + 2 ? parameters[pos+1] : "")

<< '\'' << std::endl;

// Parse parameters

if ((rv = parseRegexParam(pluginRegex, out, parameters, pos)) != CR_OK)

return rv;

if ((rv = parseRegexParam(categoryRegex, out, parameters, pos+1)) != CR_OK)

return rv;

// Lock the manager to have consistent view of categories

auto& manager = DebugManager::getInstance();

std::lock_guard<std::mutex> lock(manager.access_mutex_);

out << std::left;

auto VARIABLE_IS_NOT_USED guard = header(manager, categoryRegex, pluginRegex);

for (auto* category: manager) {

DebugCategory::cstring_ref p = category->plugin();

DebugCategory::cstring_ref c = category->category();

// Apply filters to the category and plugin names

if (!std::regex_search(c, categoryRegex))

continue;

if (!std::regex_search(p, pluginRegex))

continue;

categoryMatch(*category);

}

out << std::flush << std::right;

out.color(COLOR_RESET);

return listComplete();

{

// Output the header.

out.color(COLOR_GREEN);

out << std::setw(12) << "Plugin"

<< std::setw(12) << "Category"

<< std::setw(18) << "Lowest printed" << '\n';

unsigned& line,

DebugCategory& cat,

DebugCategory::level old = static_cast<DebugCategory::level>(-1))

{

if ((line & 31) == 0)

printCategoryListHeader(out);

// Output matching categories.

out.color((line++ & 1) == 0 ? COLOR_CYAN : COLOR_LIGHTCYAN);

const std::string& level = (old != static_cast<DebugCategory::level>(-1)) ?

levelNames[static_cast<unsigned>(old)] + "->" +

levelNames[static_cast<unsigned>(cat.allowed())] :

levelNames[static_cast<unsigned>(cat.allowed())].str();

out << std::setw(12) << cat.plugin()

<< std::setw(12) << cat.category()

<< std::setw(18) << level << '\n';

std::vector<std::string>& parameters)

{

unsigned line = 0;

return applyCategoryFilters(out, parameters, 1u,

// After parameter parsing

[](DebugManager&, const std::regex&, const std::regex&) {

return 0;

},

// Per category

[&out, &line](DebugCategory& cat) {

printCategoryListEntry(out, line, cat);

},

// After list

[]() {return CR_OK;});

using string = std::basic_string<CT, TT>;

center(const string& str) :

str_(str)

{}

const string& str_;

const std::string& parameter)

{

unsigned long id = 0;

try {

id = std::stoul(parameter);

} catch(...) {

}

auto& filMan = FilterManager::getInstance();

auto iter = filMan.find(id);

if (iter == filMan.end()) {

WARN(command,out) << "The optional parameter ("

<< parameter << ") must be an filter id." << std::endl;

}

return iter;

unsigned line,

color_value lineColor,

size_t id,

const Filter& filter)

{

if ((line & 31) == 0) {

out.color(COLOR_GREEN);

out << std::setw(4) << "ID"

<< std::setw(8) << "enabled"

<< std::setw(8) << "persist"

<< std::setw(9) << centered("level"_s)

<< ' '

<< std::setw(15) << centered("category"_s)

<< ' '

<< std::setw(15) << centered("plugin"_s)

<< std::setw(8) << "matches"

<< '\n';

}

out.color(lineColor);

out << std::setw(4) << id

<< std::setw(8) << centered(filter.enabled() ? "X"_s:""_s)

<< std::setw(8) << centered(filter.persistent() ? "X"_s:""_s)

<< std::setw(9) << centered(levelNames[filter.level()].str())

<< ' '

<< std::setw(15) << centered(filter.categoryText())

<< ' '

<< std::setw(15) << centered(filter.pluginText())

<< std::setw(8) << filter.matches()

<< '\n';

std::vector<std::string>& parameters)

{

if (1u < parameters.size()) {

auto& catMan = DebugManager::getInstance();

std::lock_guard<std::mutex> lock(catMan.access_mutex_);

auto iter = parseFilterId(out, parameters[1]);

if (iter == FilterManager::getInstance().end())

return CR_WRONG_USAGE;

auto id = iter->first;

Filter& filter = iter->second;

out << std::left

<< std::setw(10) << "ID:" << id << '\n'

<< std::setw(10) << "Enabled:" << (filter.enabled() ? "Yes"_s:"No"_s) << '\n'

<< std::setw(10) << "Persist:" << (filter.persistent() ? "Yes"_s:"No"_s) << '\n'

<< std::setw(10) << "Level:" << levelNames[filter.level()].str() << '\n'

<< std::setw(10) << "category:" << filter.categoryText() << '\n'

<< std::setw(10) << "plugin:" << filter.pluginText() << '\n'

<< std::setw(10) << "matches:" << filter.matches() << '\n'

<< std::right

<< std::endl;

return CR_OK;

}

auto& catMan = DebugManager::getInstance();

{

std::lock_guard<std::mutex> lock(catMan.access_mutex_);

auto& filMan = FilterManager::getInstance();

unsigned line = 0;

for (auto& filterPair: filMan) {

size_t id = filterPair.first;

const Filter& filter = filterPair.second;

color_value c = (line & 1) == 0 ? COLOR_CYAN : COLOR_LIGHTCYAN;

printFilterListEntry(out,line++,c,id,filter);

}

}

out.color(COLOR_RESET);

out.flush();

return CR_OK;

std::vector<std::string>& parameters)

{

bool persist = false;

size_t pos = 1u;

if (pos < parameters.size() &&

parameters[pos] == persistent) {

pos++;

persist = true;

}

if (pos >= parameters.size()) {

ERR(command,out).print("set requires at least the level parameter\n");

return CR_WRONG_USAGE;

}

const std::string& level = parameters[pos];

auto iter = std::find_if(levelNames.begin(), levelNames.end(),

[&level](const LevelName& v) -> bool {

return v.match(level);

});

if (iter == levelNames.end()) {

ERR(command,out).print("level ('{}') parameter must be one of "

"trace, debug, info, warning, error.\n",

parameters[pos]);

return CR_WRONG_USAGE;

}

DebugCategory::level filterLevel = static_cast<DebugCategory::level>(

iter - levelNames.begin());

unsigned line = 0;

Filter* newFilter = nullptr;

return applyCategoryFilters(out, parameters, pos + 1,

// After parameters parsing

[&parameters, pos, filterLevel,persist,&newFilter](DebugManager&, const std::regex& catRegex, const std::regex& pluginRegex)

{

auto& filMan = FilterManager::getInstance();

newFilter = &filMan.emplaceNew(filterLevel,

pos+1 < parameters.size()?parameters[pos+1]:".",

catRegex,

pos+2 < parameters.size()?parameters[pos+2]:".",

pluginRegex,

persist).first->second;

return filMan.blockSlot();

},

// Per item

[filterLevel, &line, &out, &newFilter](DebugCategory& cat) {

auto old = cat.allowed();

cat.allowed(filterLevel);

newFilter->addMatch();

printCategoryListEntry(out, line, cat, old);

},

// After list

[&out,&persist]() {

if (persist)

return FilterManager::getInstance().saveConfig(out);

return CR_OK;

});

std::vector<std::string>& parameters,

const char* name,

HighlightRed hlRed,

ListComplete listComplete)

{

if (1u >= parameters.size()) {

ERR(command,out) << name << " requires at least a filter id" << std::endl;

return CR_WRONG_USAGE;

}

command_result rv = CR_OK;

{

auto& catMan = DebugManager::getInstance();

std::lock_guard<std::mutex> lock(catMan.access_mutex_);

auto& filMan = FilterManager::getInstance();

unsigned line = 0;

for (size_t pos = 1; pos < parameters.size(); ++pos) {

const std::string& p = parameters[pos];

auto iter = parseFilterId(out, p);

if (iter == filMan.end())

continue;

color_value c = (line & 1) == 0 ? COLOR_CYAN : COLOR_LIGHTCYAN;

if (hlRed(iter))

c = COLOR_RED;

printFilterListEntry(out,line++,c,iter->first,iter->second);

}

rv = listComplete();

}

out.color(COLOR_RESET);

out.flush();

return rv;

std::vector<std::string>& parameters)

{

std::set<DebugCategory*> modified;

bool mustSave = false;

return applyFilterIds(out,parameters,"disable",

// Per item

[&modified,&mustSave](FilterManager::iterator& iter) -> bool {

Filter& filter = iter->second;

bool enabled = filter.enabled();

if (enabled == false)

return true;

auto& catMan = DebugManager::getInstance();

for (DebugCategory* cat: catMan) {

if (filter.remove(*cat))

modified.emplace(cat);

}

filter.enabled(false);

mustSave = mustSave || filter.persistent();

return false;

},

// After list

[&modified,&mustSave,&out]() {

for (DebugCategory* cat: modified) {

// Reset filtering back to default

cat->allowed(DebugCategory::LWARNING);

auto& filMan = FilterManager::getInstance();

// Reapply all remaining filters

for (auto& filterPair: filMan)

filterPair.second.applyAgain(*cat);

}

if (mustSave)

return FilterManager::getInstance().saveConfig(out);

return CR_OK;

});

std::vector<std::string>& parameters)

{

std::set<DebugCategory*> modified;

bool mustSave = false;

return applyFilterIds(out,parameters,"enable",

// Per item

[&modified,&mustSave](FilterManager::iterator& iter) -> bool {

Filter& filter = iter->second;

bool enabled = filter.enabled();

if (enabled == true)

return true;

filter.enabled(true);

auto& catMan = DebugManager::getInstance();

for (DebugCategory* cat: catMan) {

if (filter.applyAgain(*cat)) {

modified.emplace(cat);

filter.addMatch();

}

}

mustSave = mustSave || filter.persistent();

return false;

},

// After list

[&modified,&mustSave,&out]() {

for (DebugCategory* cat: modified) {

// Reset filtering back to default

cat->allowed(DebugCategory::LWARNING);

auto& filMan = FilterManager::getInstance();

// Reapply all remaining filters

for (auto& filterPair: filMan)

filterPair.second.applyAgain(*cat);

}

if (mustSave)

return FilterManager::getInstance().saveConfig(out);

return CR_OK;

});

std::vector<std::string>& parameters)

{

std::set<DebugCategory*> modified;

std::vector<FilterManager::iterator> toErase;

return applyFilterIds(out,parameters,"unset",

// Per item

[&modified, &toErase](FilterManager::iterator& iter) -> bool {

Filter& filter = iter->second;

if (filter.enabled()) {

auto& catMan = DebugManager::getInstance();

for (DebugCategory* cat: catMan) {

if (filter.remove(*cat))

modified.emplace(cat);

}

}

toErase.emplace_back(iter);

return false;

},

// After list

[&modified,&toErase,&out]() {

auto& filMan = FilterManager::getInstance();

bool mustSave = false;

for (auto iter: toErase) {

mustSave = mustSave || iter->second.persistent();

filMan.erase(iter);

}

for (DebugCategory* cat: modified) {

// Reset filtering back to default

cat->allowed(DebugCategory::LWARNING);

// Reapply all remaining filters

for (auto& filterPair: filMan)

filterPair.second.applyAgain(*cat);

}

if (mustSave)

return FilterManager::getInstance().saveConfig(out);

return CR_OK;

});