diff --git a/plugins/logistics.cpp b/plugins/logistics.cpp index d4c4cef53..804aa5fe3 100644 --- a/plugins/logistics.cpp +++ b/plugins/logistics.cpp @@ -608,7 +608,7 @@ static int logistics_getStockpileConfigs(lua_State *L) { color_ostream *out = Lua::GetOutput(L); if (!out) out = &Core::getInstance().getConsole(); - DEBUG(status, *out).print("entering logistics_getStockpileConfig\n"); + DEBUG(status, *out).print("entering logistics_getStockpileConfigs\n"); unordered_map cache; validate_stockpile_configs(*out, cache); diff --git a/plugins/lua/stockpiles.lua b/plugins/lua/stockpiles.lua index 3590dc1f9..3e03d9eda 100644 --- a/plugins/lua/stockpiles.lua +++ b/plugins/lua/stockpiles.lua @@ -207,6 +207,11 @@ function parse_commandline(args) return true end +function get_stockpile_features(stockpile_number) + local config = logistics.logistics_getStockpileConfigs(stockpile_number)[1] + return config.melt, config.trade, config.dump +end + -------------------- -- dialogs -------------------- diff --git a/plugins/stockpiles/OrganicMatLookup.cpp b/plugins/stockpiles/OrganicMatLookup.cpp index 91294809b..1efdd4df6 100644 --- a/plugins/stockpiles/OrganicMatLookup.cpp +++ b/plugins/stockpiles/OrganicMatLookup.cpp @@ -21,8 +21,8 @@ DBG_EXTERN(stockpiles, log); * and their index in the stockpile_settings structures. */ -void OrganicMatLookup::food_mat_by_idx(organic_mat_category::organic_mat_category mat_category, std::vector::size_type food_idx, FoodMat& food_mat) { - DEBUG(log).print("food_lookup: food_idx(%zd)\n", food_idx); +void OrganicMatLookup::food_mat_by_idx(color_ostream& out, organic_mat_category::organic_mat_category mat_category, std::vector::size_type food_idx, FoodMat& food_mat) { + DEBUG(log, out).print("food_lookup: food_idx(%zd)\n", food_idx); df::world_raws& raws = world->raws; df::special_mat_table table = raws.mat_table; int32_t main_idx = table.organic_indexes[mat_category][food_idx]; @@ -32,16 +32,16 @@ void OrganicMatLookup::food_mat_by_idx(organic_mat_category::organic_mat_categor mat_category == organic_mat_category::Eggs) { food_mat.creature = raws.creatures.all[type]; food_mat.caste = food_mat.creature->caste[main_idx]; - DEBUG(log).print("special creature type(%d) caste(%d)\n", type, main_idx); + DEBUG(log, out).print("special creature type(%d) caste(%d)\n", type, main_idx); } else { food_mat.material.decode(type, main_idx); - DEBUG(log).print("type(%d) index(%d) token(%s)\n", type, main_idx, food_mat.material.getToken().c_str()); + DEBUG(log, out).print("type(%d) index(%d) token(%s)\n", type, main_idx, food_mat.material.getToken().c_str()); } } -std::string OrganicMatLookup::food_token_by_idx(organic_mat_category::organic_mat_category mat_category, std::vector::size_type idx) { +std::string OrganicMatLookup::food_token_by_idx(color_ostream& out, organic_mat_category::organic_mat_category mat_category, std::vector::size_type idx) { FoodMat food_mat; - food_mat_by_idx(mat_category, idx, food_mat); + food_mat_by_idx(out, mat_category, idx, food_mat); if (food_mat.material.isValid()) { return food_mat.material.getToken(); } @@ -72,32 +72,32 @@ void OrganicMatLookup::food_build_map() { index_built = true; } -int16_t OrganicMatLookup::food_idx_by_token(organic_mat_category::organic_mat_category mat_category, const std::string& token) { +int16_t OrganicMatLookup::food_idx_by_token(color_ostream& out, organic_mat_category::organic_mat_category mat_category, const std::string& token) { df::world_raws& raws = world->raws; df::special_mat_table table = raws.mat_table; - DEBUG(log).print("food_idx_by_token:\n"); + DEBUG(log, out).print("food_idx_by_token:\n"); if (mat_category == organic_mat_category::Fish || mat_category == organic_mat_category::UnpreparedFish || mat_category == organic_mat_category::Eggs) { std::vector tokens; split_string(&tokens, token, ":"); if (tokens.size() != 2) { - WARN(log).print("creature invalid CREATURE:CASTE token: %s\n", token.c_str()); + WARN(log, out).print("creature invalid CREATURE:CASTE token: %s\n", token.c_str()); return -1; } int16_t creature_idx = find_creature(tokens[0]); if (creature_idx < 0) { - WARN(log).print("creature invalid token %s\n", tokens[0].c_str()); + WARN(log, out).print("creature invalid token %s\n", tokens[0].c_str()); return -1; } int16_t food_idx = linear_index(table.organic_types[mat_category], creature_idx); if (tokens[1] == "MALE") food_idx += 1; if (table.organic_types[mat_category][food_idx] == creature_idx) { - DEBUG(log).print("creature %s caste %s creature_idx(%d) food_idx(%d)\n", token.c_str(), tokens[1].c_str(), creature_idx, food_idx); + DEBUG(log, out).print("creature %s caste %s creature_idx(%d) food_idx(%d)\n", token.c_str(), tokens[1].c_str(), creature_idx, food_idx); return food_idx; } - WARN(log).print("creature caste not found: %s caste %s creature_idx(%d) food_idx(%d)\n", token.c_str(), tokens[1].c_str(), creature_idx, food_idx); + WARN(log, out).print("creature caste not found: %s caste %s creature_idx(%d) food_idx(%d)\n", token.c_str(), tokens[1].c_str(), creature_idx, food_idx); return -1; } @@ -108,12 +108,12 @@ int16_t OrganicMatLookup::food_idx_by_token(organic_mat_category::organic_mat_ca int32_t index = mat_info.index; auto it = food_index[mat_category].find(std::make_pair(type, index)); if (it != food_index[mat_category].end()) { - DEBUG(log).print("matinfo: %s type(%d) idx(%d) food_idx(%zd)\n", token.c_str(), mat_info.type, mat_info.index, it->second); + DEBUG(log, out).print("matinfo: %s type(%d) idx(%d) food_idx(%zd)\n", token.c_str(), mat_info.type, mat_info.index, it->second); return it->second; } - WARN(log).print("matinfo: %s type(%d) idx(%d) food_idx not found :(\n", token.c_str(), mat_info.type, mat_info.index); + WARN(log, out).print("matinfo: %s type(%d) idx(%d) food_idx not found :(\n", token.c_str(), mat_info.type, mat_info.index); return -1; } diff --git a/plugins/stockpiles/OrganicMatLookup.h b/plugins/stockpiles/OrganicMatLookup.h index 7ae65b17e..37e019b58 100644 --- a/plugins/stockpiles/OrganicMatLookup.h +++ b/plugins/stockpiles/OrganicMatLookup.h @@ -28,13 +28,13 @@ public: FoodMat(): material(-1), creature(0), caste(0) { } }; - static void food_mat_by_idx(df::enums::organic_mat_category::organic_mat_category mat_category, std::vector::size_type food_idx, FoodMat& food_mat); - static std::string food_token_by_idx(df::enums::organic_mat_category::organic_mat_category mat_category, std::vector::size_type idx); + static void food_mat_by_idx(DFHack::color_ostream& out, df::enums::organic_mat_category::organic_mat_category mat_category, std::vector::size_type food_idx, FoodMat& food_mat); + static std::string food_token_by_idx(DFHack::color_ostream& out, df::enums::organic_mat_category::organic_mat_category mat_category, std::vector::size_type idx); static size_t food_max_size(df::enums::organic_mat_category::organic_mat_category mat_category); static void food_build_map(); - static int16_t food_idx_by_token(df::enums::organic_mat_category::organic_mat_category mat_category, const std::string& token); + static int16_t food_idx_by_token(DFHack::color_ostream& out, df::enums::organic_mat_category::organic_mat_category mat_category, const std::string& token); static DFHack::MaterialInfo food_mat_by_token(const std::string& token); diff --git a/plugins/stockpiles/StockpileSerializer.cpp b/plugins/stockpiles/StockpileSerializer.cpp index 2908f3329..f6091b9cd 100644 --- a/plugins/stockpiles/StockpileSerializer.cpp +++ b/plugins/stockpiles/StockpileSerializer.cpp @@ -41,6 +41,7 @@ using namespace dfstockpiles; using df::global::world; using std::placeholders::_1; +using std::placeholders::_2; namespace DFHack { @@ -162,11 +163,11 @@ StockpileSerializer::StockpileSerializer(df::building_stockpilest* stockpile) StockpileSerializer::~StockpileSerializer() { } -bool StockpileSettingsSerializer::serialize_to_ostream(std::ostream* output, uint32_t includedElements) { +bool StockpileSettingsSerializer::serialize_to_ostream(color_ostream& out, std::ostream* output, uint32_t includedElements) { if (output->fail()) return false; mBuffer.Clear(); - write(includedElements); + write(out, includedElements); { io::OstreamOutputStream zero_copy_output(output); if (!mBuffer.SerializeToZeroCopyStream(&zero_copy_output)) @@ -175,14 +176,14 @@ bool StockpileSettingsSerializer::serialize_to_ostream(std::ostream* output, uin return output->good(); } -bool StockpileSettingsSerializer::serialize_to_file(const string& file, uint32_t includedElements) { +bool StockpileSettingsSerializer::serialize_to_file(color_ostream& out, const string& file, uint32_t includedElements) { std::fstream output(file, std::ios::out | std::ios::binary | std::ios::trunc); if (output.fail()) { - WARN(log).print("ERROR: failed to open file for writing: '%s'\n", + WARN(log, out).print("ERROR: failed to open file for writing: '%s'\n", file.c_str()); return false; } - return serialize_to_ostream(&output, includedElements); + return serialize_to_ostream(out, &output, includedElements); } bool StockpileSettingsSerializer::parse_from_istream(color_ostream &out, std::istream* input, DeserializeMode mode, const vector& filters) { @@ -200,7 +201,7 @@ bool StockpileSettingsSerializer::parse_from_istream(color_ostream &out, std::is bool StockpileSettingsSerializer::unserialize_from_file(color_ostream &out, const string& file, DeserializeMode mode, const vector& filters) { std::fstream input(file, std::ios::in | std::ios::binary); if (input.fail()) { - WARN(log).print("failed to open file for reading: '%s'\n", + WARN(log, out).print("failed to open file for reading: '%s'\n", file.c_str()); return false; } @@ -229,37 +230,37 @@ static typename df::enum_traits::base_type linear_index(df::enum_traits tr return -1; } -static bool matches_filter(const vector& filters, const string& name) { +static bool matches_filter(color_ostream& out, const vector& filters, const string& name) { for (auto & filter : filters) { - DEBUG(log).print("searching for '%s' in '%s'\n", filter.c_str(), name.c_str()); + DEBUG(log, out).print("searching for '%s' in '%s'\n", filter.c_str(), name.c_str()); if (std::search(name.begin(), name.end(), filter.begin(), filter.end(), [](unsigned char ch1, unsigned char ch2) { return std::toupper(ch1) == std::toupper(ch2); } - ) != name.end()) + ) != name.end()) return true; } return !filters.size(); } -static void set_flag(const char* name, const vector& filters, bool all, char val, bool enabled, bool& elem) { - if ((all || enabled) && matches_filter(filters, name)) { - DEBUG(log).print("setting %s to %d\n", name, val); +static void set_flag(color_ostream& out, const char* name, const vector& filters, bool all, char val, bool enabled, bool& elem) { + if ((all || enabled) && matches_filter(out, filters, name)) { + DEBUG(log, out).print("setting %s to %d\n", name, val); elem = val; } } -static void set_filter_elem(const char* subcat, const vector& filters, char val, +static void set_filter_elem(color_ostream& out, const char* subcat, const vector& filters, char val, const string& name, const string& id, char& elem) { - if (matches_filter(filters, subcat + ((*subcat ? "/" : "") + name))) { - DEBUG(log).print("setting %s (%s) to %d\n", name.c_str(), id.c_str(), val); + if (matches_filter(out, filters, subcat + ((*subcat ? "/" : "") + name))) { + DEBUG(log, out).print("setting %s (%s) to %d\n", name.c_str(), id.c_str(), val); elem = val; } } template -static void set_filter_elem(const char* subcat, const vector& filters, T_val val, +static void set_filter_elem(color_ostream& out, const char* subcat, const vector& filters, T_val val, const string& name, T_id id, T_val& elem) { - if (matches_filter(filters, subcat + ((*subcat ? "/" : "") + name))) { - DEBUG(log).print("setting %s (%d) to %d\n", name.c_str(), (int32_t)id, val); + if (matches_filter(out, filters, subcat + ((*subcat ? "/" : "") + name))) { + DEBUG(log, out).print("setting %s (%d) to %d\n", name.c_str(), (int32_t)id, val); elem = val; } } @@ -277,7 +278,7 @@ static void set_filter_elem(const char* subcat, const vector& filters, T * * The unserialization process is the same in reverse. */ -static bool serialize_list_itemdef(FuncWriteExport add_value, +static bool serialize_list_itemdef(color_ostream& out, FuncWriteExport add_value, vector list, vector items, item_type::item_type type) { @@ -294,13 +295,13 @@ static bool serialize_list_itemdef(FuncWriteExport add_value, ItemTypeInfo ii; if (!ii.decode(type, i)) continue; - DEBUG(log).print("adding itemdef type %s\n", ii.getToken().c_str()); + DEBUG(log, out).print("adding itemdef type %s\n", ii.getToken().c_str()); add_value(ii.getToken()); } return all; } -static void unserialize_list_itemdef(const char* subcat, bool all, char val, const vector& filters, +static void unserialize_list_itemdef(color_ostream& out, const char* subcat, bool all, char val, const vector& filters, FuncReadImport read_value, int32_t list_size, vector& pile_list, item_type::item_type type) { int num_elems = Items::getSubtypeCount(type); pile_list.resize(num_elems, '\0'); @@ -308,7 +309,7 @@ static void unserialize_list_itemdef(const char* subcat, bool all, char val, con for (auto idx = 0; idx < num_elems; ++idx) { ItemTypeInfo ii; ii.decode(type, idx); - set_filter_elem(subcat, filters, val, ii.toString(), idx, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, ii.toString(), idx, pile_list.at(idx)); } return; } @@ -319,14 +320,14 @@ static void unserialize_list_itemdef(const char* subcat, bool all, char val, con if (!ii.find(id)) continue; if (ii.subtype < 0 || size_t(ii.subtype) >= pile_list.size()) { - WARN(log).print("item type index invalid: %d\n", ii.subtype); + WARN(log, out).print("item type index invalid: %d\n", ii.subtype); continue; } - set_filter_elem(subcat, filters, val, id, ii.subtype, pile_list.at(ii.subtype)); + set_filter_elem(out, subcat, filters, val, id, ii.subtype, pile_list.at(ii.subtype)); } } -static bool serialize_list_quality(FuncWriteExport add_value, +static bool serialize_list_quality(color_ostream& out, FuncWriteExport add_value, const bool(&quality_list)[7]) { using df::enums::item_quality::item_quality; using quality_traits = df::enum_traits; @@ -339,7 +340,7 @@ static bool serialize_list_quality(FuncWriteExport add_value, } const string f_type(quality_traits::key_table[i]); add_value(f_type); - DEBUG(log).print("adding quality %s\n", f_type.c_str()); + DEBUG(log, out).print("adding quality %s\n", f_type.c_str()); } return all; } @@ -348,12 +349,12 @@ static void quality_clear(bool(&pile_list)[7]) { std::fill(pile_list, pile_list + 7, false); } -static void unserialize_list_quality(const char* subcat, bool all, bool val, const vector& filters, +static void unserialize_list_quality(color_ostream& out, const char* subcat, bool all, bool val, const vector& filters, FuncReadImport read_value, int32_t list_size, bool(&pile_list)[7]) { if (all) { for (auto idx = 0; idx < 7; ++idx) { string id = ENUM_KEY_STR(item_quality, (df::item_quality)idx); - set_filter_elem(subcat, filters, val, id, idx, pile_list[idx]); + set_filter_elem(out, subcat, filters, val, id, idx, pile_list[idx]); } return; } @@ -364,10 +365,10 @@ static void unserialize_list_quality(const char* subcat, bool all, bool val, con const string quality = read_value(i); df::enum_traits::base_type idx = linear_index(quality_traits, quality); if (idx < 0) { - WARN(log).print("invalid quality token: %s\n", quality.c_str()); + WARN(log, out).print("invalid quality token: %s\n", quality.c_str()); continue; } - set_filter_elem(subcat, filters, val, quality, idx, pile_list[idx]); + set_filter_elem(out, subcat, filters, val, quality, idx, pile_list[idx]); } } @@ -388,7 +389,7 @@ static int other_mats_token(const std::map other_mats, return -1; } -static bool serialize_list_other_mats( +static bool serialize_list_other_mats(color_ostream& out, const std::map other_mats, FuncWriteExport add_value, vector list) { @@ -400,23 +401,23 @@ static bool serialize_list_other_mats( } const string token = other_mats_index(other_mats, i); if (token.empty()) { - WARN(log).print("invalid other material with index %zd\n", i); + WARN(log, out).print("invalid other material with index %zd\n", i); continue; } add_value(token); - DEBUG(log).print("other mats %zd is %s\n", i, token.c_str()); + DEBUG(log, out).print("other mats %zd is %s\n", i, token.c_str()); } return all; } -static void unserialize_list_other_mats(const char* subcat, bool all, char val, const vector& filters, +static void unserialize_list_other_mats(color_ostream& out, const char* subcat, bool all, char val, const vector& filters, const std::map other_mats, FuncReadImport read_value, int32_t list_size, vector& pile_list) { size_t num_elems = other_mats.size(); pile_list.resize(num_elems, '\0'); if (all) { for (auto & entry : other_mats) - set_filter_elem(subcat, filters, val, entry.second, entry.first, pile_list.at(entry.first)); + set_filter_elem(out, subcat, filters, val, entry.second, entry.first, pile_list.at(entry.first)); return; } @@ -424,23 +425,23 @@ static void unserialize_list_other_mats(const char* subcat, bool all, char val, const string token = read_value(i); size_t idx = other_mats_token(other_mats, token); if (idx < 0) { - WARN(log).print("invalid other mat with token %s\n", token.c_str()); + WARN(log, out).print("invalid other mat with token %s\n", token.c_str()); continue; } if (idx >= num_elems) { - WARN(log).print("other_mats index too large! idx[%zd] max_size[%zd]\n", idx, num_elems); + WARN(log, out).print("other_mats index too large! idx[%zd] max_size[%zd]\n", idx, num_elems); continue; } - set_filter_elem(subcat, filters, val, token, idx, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, token, idx, pile_list.at(idx)); } } -static bool serialize_list_organic_mat(FuncWriteExport add_value, +static bool serialize_list_organic_mat(color_ostream& out, FuncWriteExport add_value, const vector* list, organic_mat_category::organic_mat_category cat) { bool all = true; if (!list) { - DEBUG(log).print("serialize_list_organic_mat: list null\n"); + DEBUG(log, out).print("serialize_list_organic_mat: list null\n"); return all; } for (size_t i = 0; i < list->size(); ++i) { @@ -448,49 +449,49 @@ static bool serialize_list_organic_mat(FuncWriteExport add_value, all = false; continue; } - string token = OrganicMatLookup::food_token_by_idx(cat, i); + string token = OrganicMatLookup::food_token_by_idx(out, cat, i); if (token.empty()) { - DEBUG(log).print("food mat invalid :(\n"); + DEBUG(log, out).print("food mat invalid :(\n"); continue; } - DEBUG(log).print("organic_material %zd is %s\n", i, token.c_str()); + DEBUG(log, out).print("organic_material %zd is %s\n", i, token.c_str()); add_value(token); } return all; } -static void unserialize_list_organic_mat(const char* subcat, bool all, char val, const vector& filters, +static void unserialize_list_organic_mat(color_ostream& out, const char* subcat, bool all, char val, const vector& filters, FuncReadImport read_value, size_t list_size, vector& pile_list, organic_mat_category::organic_mat_category cat) { size_t num_elems = OrganicMatLookup::food_max_size(cat); pile_list.resize(num_elems, '\0'); if (all) { for (size_t idx = 0; idx < num_elems; ++idx) { - string token = OrganicMatLookup::food_token_by_idx(cat, idx); - set_filter_elem(subcat, filters, val, token, idx, pile_list.at(idx)); + string token = OrganicMatLookup::food_token_by_idx(out, cat, idx); + set_filter_elem(out, subcat, filters, val, token, idx, pile_list.at(idx)); } return; } for (size_t i = 0; i < list_size; ++i) { const string token = read_value(i); - int16_t idx = OrganicMatLookup::food_idx_by_token(cat, token); + int16_t idx = OrganicMatLookup::food_idx_by_token(out, cat, token); if (idx < 0 || size_t(idx) >= num_elems) { - WARN(log).print("organic mat index too large! idx[%d] max_size[%zd]\n", idx, num_elems); + WARN(log, out).print("organic mat index too large! idx[%d] max_size[%zd]\n", idx, num_elems); continue; } - set_filter_elem(subcat, filters, val, token, idx, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, token, idx, pile_list.at(idx)); } } -static bool serialize_list_item_type(FuncItemAllowed is_allowed, +static bool serialize_list_item_type(color_ostream& out, FuncItemAllowed is_allowed, FuncWriteExport add_value, const vector& list) { using df::enums::item_type::item_type; using type_traits = df::enum_traits; bool all = true; size_t num_item_types = list.size(); - DEBUG(log).print("item_type size = %zd size limit = %d typecasted: %zd\n", + DEBUG(log, out).print("item_type size = %zd size limit = %d typecasted: %zd\n", num_item_types, type_traits::last_item_value, (size_t)type_traits::last_item_value); for (size_t i = 0; i <= (size_t)type_traits::last_item_value; ++i) { @@ -503,12 +504,12 @@ static bool serialize_list_item_type(FuncItemAllowed is_allowed, if (!is_allowed(type)) continue; add_value(r_type); - DEBUG(log).print("item_type key_table[%zd] type[%d] is %s\n", i + 1, (int16_t)type, r_type.c_str()); + DEBUG(log, out).print("item_type key_table[%zd] type[%d] is %s\n", i + 1, (int16_t)type, r_type.c_str()); } return all; } -static void unserialize_list_item_type(const char* subcat, bool all, char val, const vector& filters, +static void unserialize_list_item_type(color_ostream& out, const char* subcat, bool all, char val, const vector& filters, FuncItemAllowed is_allowed, FuncReadImport read_value, int32_t list_size, vector& pile_list) { // TODO can we remove the hardcoded list size? size_t num_elems = 112; @@ -521,7 +522,7 @@ static void unserialize_list_item_type(const char* subcat, bool all, char val, c if (all) { for (size_t idx = 0; idx < num_elems; ++idx) { string id = ENUM_KEY_STR(item_type, (df::item_type)idx); - set_filter_elem(subcat, filters, val, id, idx, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, id, idx, pile_list.at(idx)); } return; } @@ -535,14 +536,14 @@ static void unserialize_list_item_type(const char* subcat, bool all, char val, c if (!is_allowed((item_type)idx)) continue; if (idx < 0 || size_t(idx) >= num_elems) { - WARN(log).print("error item_type index too large! idx[%d] max_size[%zd]\n", idx, num_elems); + WARN(log, out).print("error item_type index too large! idx[%d] max_size[%zd]\n", idx, num_elems); continue; } - set_filter_elem(subcat, filters, val, token, idx, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, token, idx, pile_list.at(idx)); } } -static bool serialize_list_material(FuncMaterialAllowed is_allowed, +static bool serialize_list_material(color_ostream& out, FuncMaterialAllowed is_allowed, FuncWriteExport add_value, const vector& list) { bool all = true; MaterialInfo mi; @@ -554,13 +555,13 @@ static bool serialize_list_material(FuncMaterialAllowed is_allowed, mi.decode(0, i); if (!is_allowed(mi)) continue; - DEBUG(log).print("adding material %s\n", mi.getToken().c_str()); + DEBUG(log, out).print("adding material %s\n", mi.getToken().c_str()); add_value(mi.getToken()); } return all; } -static void unserialize_list_material(const char* subcat, bool all, char val, const vector& filters, +static void unserialize_list_material(color_ostream& out, const char* subcat, bool all, char val, const vector& filters, FuncMaterialAllowed is_allowed, FuncReadImport read_value, int32_t list_size, vector& pile_list) { // we initialize all disallowed values to 1 @@ -577,7 +578,7 @@ static void unserialize_list_material(const char* subcat, bool all, char val, co for (size_t idx = 0; idx < num_elems; ++idx) { MaterialInfo mi; mi.decode(0, idx); - set_filter_elem(subcat, filters, val, mi.toString(), idx, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, mi.toString(), idx, pile_list.at(idx)); } return; } @@ -588,14 +589,14 @@ static void unserialize_list_material(const char* subcat, bool all, char val, co if (!mi.find(id) || !is_allowed(mi)) continue; if (mi.index < 0 || size_t(mi.index) >= pile_list.size()) { - WARN(log).print("material type index invalid: %d\n", mi.index); + WARN(log, out).print("material type index invalid: %d\n", mi.index); continue; } - set_filter_elem(subcat, filters, val, id, mi.index, pile_list.at(mi.index)); + set_filter_elem(out, subcat, filters, val, id, mi.index, pile_list.at(mi.index)); } } -static bool serialize_list_creature(FuncWriteExport add_value, const vector& list) { +static bool serialize_list_creature(color_ostream& out, FuncWriteExport add_value, const vector& list) { bool all = true; for (size_t i = 0; i < list.size(); ++i) { @@ -607,7 +608,7 @@ static bool serialize_list_creature(FuncWriteExport add_value, const vectorflags.is_set(creature_raw_flags::GENERATED) || r->creature_id == "EQUIPMENT_WAGON") continue; - DEBUG(log).print("adding creature %s\n", r->creature_id.c_str()); + DEBUG(log, out).print("adding creature %s\n", r->creature_id.c_str()); add_value(r->creature_id); } return all; @@ -619,14 +620,14 @@ static string get_filter_string(df::creature_raw *r) { return r->name[0] + "/tameable"; } -static void unserialize_list_creature(const char* subcat, bool all, char val, const vector& filters, +static void unserialize_list_creature(color_ostream& out, const char* subcat, bool all, char val, const vector& filters, FuncReadImport read_value, int32_t list_size, vector& pile_list) { size_t num_elems = world->raws.creatures.all.size(); pile_list.resize(num_elems, '\0'); if (all) { for (size_t idx = 0; idx < num_elems; ++idx) { auto r = find_creature(idx); - set_filter_elem(subcat, filters, val, get_filter_string(r), r->creature_id, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, get_filter_string(r), r->creature_id, pile_list.at(idx)); } return; } @@ -635,42 +636,43 @@ static void unserialize_list_creature(const char* subcat, bool all, char val, co string id = read_value(i); int idx = find_creature(id); if (idx < 0 || size_t(idx) >= num_elems) { - WARN(log).print("animal index invalid: %d\n", idx); + WARN(log, out).print("animal index invalid: %d\n", idx); continue; } auto r = find_creature(idx); - set_filter_elem(subcat, filters, val, get_filter_string(r), r->creature_id, pile_list.at(idx)); + set_filter_elem(out, subcat, filters, val, get_filter_string(r), r->creature_id, pile_list.at(idx)); } } template -static void write_cat(const char *name, bool include_types, uint32_t cat_flags, - enum df::stockpile_group_set::Mask cat_mask, - std::function mutable_cat_fn, - std::function write_cat_fn) { +static void write_cat(color_ostream& out, const char* name, bool include_types, uint32_t cat_flags, + enum df::stockpile_group_set::Mask cat_mask, + std::function mutable_cat_fn, + std::function write_cat_fn) { + if (!(cat_flags & cat_mask)) return; T_cat_set* cat_set = mutable_cat_fn(); if (!include_types) { - DEBUG(log).print("including all for %s since only category is being recorded\n", name); + DEBUG(log, out).print("including all for %s since only category is being recorded\n", name); cat_set->set_all(true); return; } - if (write_cat_fn(cat_set)) { + if (write_cat_fn(out, cat_set)) { // all fields were set. clear them and use the "all" flag instead so "all" can be applied // to other worlds with other generated types - DEBUG(log).print("including all for %s since all fields were enabled\n", name); + DEBUG(log, out).print("including all for %s since all fields were enabled\n", name); cat_set->Clear(); cat_set->set_all(true); } } -void StockpileSettingsSerializer::write(uint32_t includedElements) { +void StockpileSettingsSerializer::write(color_ostream& out, uint32_t includedElements) { if (includedElements & INCLUDED_ELEMENTS_GENERAL) - write_general(); + write_general(out); if (!(includedElements & INCLUDED_ELEMENTS_CATEGORIES)) return; @@ -767,11 +769,11 @@ void StockpileSettingsSerializer::write(uint32_t includedElements) { std::bind(&StockpileSettingsSerializer::write_wood, this, _1)); } -void StockpileSerializer::write(uint32_t includedElements) { +void StockpileSerializer::write(color_ostream& out, uint32_t includedElements) { if (includedElements & INCLUDED_ELEMENTS_FEATURES) - write_features(); + write_features(out); if (includedElements & INCLUDED_ELEMENTS_CONTAINERS) - write_containers(); + write_containers(out); StockpileSettingsSerializer::write(includedElements); } @@ -796,30 +798,30 @@ void StockpileSettingsSerializer::read(color_ostream &out, DeserializeMode mode, StockpileSettings::CorpsesSet* corpses = mBuffer.mutable_corpses_v50(); corpses->set_all(true); } - read_corpses(mode, filters); + read_corpses(out, mode, filters); - read_refuse(mode, filters); - read_sheet(mode, filters); - read_stone(mode, filters); - read_weapons(mode, filters); - read_wood(mode, filters); + read_refuse(out, mode, filters); + read_sheet(out, mode, filters); + read_stone(out, mode, filters); + read_weapons(out, mode, filters); + read_wood(out, mode, filters); } void StockpileSerializer::read(color_ostream &out, DeserializeMode mode, const vector& filters) { read_features(out, mode); - read_containers(mode); - StockpileSettingsSerializer::read(mode, filters); + read_containers(out, mode); + StockpileSettingsSerializer::read(out, mode, filters); } -void StockpileSerializer::write_containers() { - DEBUG(log).print("writing container settings\n"); +void StockpileSerializer::write_containers(color_ostream& out) { + DEBUG(log, out).print("writing container settings\n"); mBuffer.set_max_bins(mPile->max_bins); mBuffer.set_max_barrels(mPile->max_barrels); mBuffer.set_max_wheelbarrows(mPile->max_wheelbarrows); } template -static void read_elem(const char *name, DeserializeMode mode, +static void read_elem(color_ostream& out, const char* name, DeserializeMode mode, std::function has_elem_fn, std::function elem_fn, T_elem &setting) { @@ -829,13 +831,13 @@ static void read_elem(const char *name, DeserializeMode mode, bool is_set = elem_fn() != 0; if (mode == DESERIALIZE_MODE_SET || is_set) { T_elem val = (mode == DESERIALIZE_MODE_DISABLE) ? 0 : elem_fn(); - DEBUG(log).print("setting %s to %d\n", name, val); + DEBUG(log, out).print("setting %s to %d\n", name, val); setting = val; } } template -static void read_category(const char *name, DeserializeMode mode, +static void read_category(color_ostream& out, const char* name, DeserializeMode mode, std::function has_cat_fn, std::function cat_fn, uint32_t & cat_flags, @@ -843,7 +845,7 @@ static void read_category(const char *name, DeserializeMode mode, std::function clear_fn, std::function set_fn) { if (mode == DESERIALIZE_MODE_SET) { - DEBUG(log).print("clearing %s\n", name); + DEBUG(log, out).print("clearing %s\n", name); cat_flags &= ~cat_mask; clear_fn(); } @@ -859,81 +861,97 @@ static void read_category(const char *name, DeserializeMode mode, bool all = cat_fn().all(); char val = (mode == DESERIALIZE_MODE_DISABLE) ? (char)0 : (char)1; - DEBUG(log).print("setting %s %s elements to %d\n", + DEBUG(log, out).print("setting %s %s elements to %d\n", all ? "all" : "marked", name, val); set_fn(all, val); } -void StockpileSerializer::read_containers(DeserializeMode mode) { - read_elem("max_bins", mode, +void StockpileSerializer::read_containers(color_ostream& out, DeserializeMode mode) { + read_elem(out, "max_bins", mode, std::bind(&StockpileSettings::has_max_bins, mBuffer), std::bind(&StockpileSettings::max_bins, mBuffer), mPile->max_bins); - read_elem("max_barrels", mode, + read_elem(out, "max_barrels", mode, std::bind(&StockpileSettings::has_max_barrels, mBuffer), std::bind(&StockpileSettings::max_barrels, mBuffer), mPile->max_barrels); - read_elem("max_wheelbarrows", mode, + read_elem(out, "max_wheelbarrows", mode, std::bind(&StockpileSettings::has_max_wheelbarrows, mBuffer), std::bind(&StockpileSettings::max_wheelbarrows, mBuffer), mPile->max_wheelbarrows); } -void StockpileSettingsSerializer::write_general() { - DEBUG(log).print("writing general settings\n"); +void StockpileSettingsSerializer::write_general(color_ostream& out) { + DEBUG(log, out).print("writing general settings\n"); mBuffer.set_allow_inorganic(mSettings->allow_inorganic); mBuffer.set_allow_organic(mSettings->allow_organic); } -void StockpileSerializer::write_general() { - StockpileSettingsSerializer::write_general(); +void StockpileSerializer::write_general(color_ostream& out) { + StockpileSettingsSerializer::write_general(out); mBuffer.set_use_links_only(mPile->use_links_only); } -void StockpileSettingsSerializer::read_general(DeserializeMode mode) { - read_elem("allow_inorganic", mode, +void StockpileSettingsSerializer::read_general(color_ostream& out, DeserializeMode mode) { + read_elem(out, "allow_inorganic", mode, std::bind(&StockpileSettings::has_allow_inorganic, mBuffer), std::bind(&StockpileSettings::allow_inorganic, mBuffer), mSettings->allow_inorganic); - read_elem("allow_organic", mode, + read_elem(out, "allow_organic", mode, std::bind(&StockpileSettings::has_allow_organic, mBuffer), std::bind(&StockpileSettings::allow_organic, mBuffer), mSettings->allow_organic); } -void StockpileSerializer::read_general(DeserializeMode mode) { - StockpileSettingsSerializer::read_general(mode); - read_elem("use_links_only", mode, +void StockpileSerializer::read_general(color_ostream& out, DeserializeMode mode) { + StockpileSettingsSerializer::read_general(out, mode); + read_elem(out, "use_links_only", mode, std::bind(&StockpileSettings::has_use_links_only, mBuffer), std::bind(&StockpileSettings::use_links_only, mBuffer), mPile->use_links_only); } -void StockpileSerializer::write_features() { - DEBUG(log).print("writing feature settings\n"); - mBuffer.set_melt(mPile->use_links_only); - mBuffer.set_trade(mPile->settings.allow_inorganic); - mBuffer.set_dump(mPile->settings.allow_organic); +void StockpileSerializer::write_features(color_ostream& out) { + DEBUG(log, out).print("writing feature settings\n"); + if (!call_stockpiles_lua(&out, "get_stockpile_features", 1, 3, + [&](lua_State* L) { + Lua::Push(L, mPile->stockpile_number); + }, + [&](lua_State* L) { + mBuffer.set_melt(0 != lua_toboolean(L, -1)); + mBuffer.set_trade(0 != lua_toboolean(L, -2)); + mBuffer.set_dump(0 != lua_toboolean(L, -3)); + })) { + + WARN(log, out).print("failed to get logistics features of stockpile number %d\n", mPile->stockpile_number); + } } void StockpileSerializer::read_features(color_ostream &out, DeserializeMode mode) { int32_t melt = -1, trade = -1, dump = -1; - read_elem("melt", mode, + read_elem(out, "melt", mode, std::bind(&StockpileSettings::has_melt, mBuffer), std::bind(&StockpileSettings::melt, mBuffer), melt); - read_elem("trade", mode, + read_elem(out, "trade", mode, std::bind(&StockpileSettings::has_trade, mBuffer), std::bind(&StockpileSettings::trade, mBuffer), trade); - read_elem("dump", mode, + read_elem(out, "dump", mode, std::bind(&StockpileSettings::has_dump, mBuffer), std::bind(&StockpileSettings::dump, mBuffer), dump); if (melt != -1 || trade != -1 || dump != -1) { - auto &core = Core::getInstance(); - core.runCommand(out, "logistics clear -s " + int_to_string(mPile->stockpile_number)); + if (!call_stockpiles_lua(&out, "set_stockpile_features", 4, 0, + [&](lua_State* L) { + Lua::Push(L, mPile->stockpile_number); + Lua::Push(L, melt == 1); + Lua::Push(L, trade == 1); + Lua::Push(L, dump == 1); + })) { + WARN(log, out).print("failed to set logistics features of stockpile number %d\n", mPile->stockpile_number); + } } } @@ -941,21 +959,21 @@ static bool ammo_mat_is_allowed(const MaterialInfo& mi) { return mi.isValid() && mi.material && mi.material->flags.is_set(material_flags::IS_METAL); } -bool StockpileSettingsSerializer::write_ammo(StockpileSettings::AmmoSet* ammo) { - bool all = serialize_list_itemdef( +bool StockpileSettingsSerializer::write_ammo(color_ostream& out, StockpileSettings::AmmoSet* ammo) { + bool all = serialize_list_itemdef(out, [&](const string& token) { ammo->add_type(token); }, mSettings->ammo.type, vector(world->raws.itemdefs.ammo.begin(), world->raws.itemdefs.ammo.end()), item_type::AMMO); - all = serialize_list_material( + all = serialize_list_material(out, ammo_mat_is_allowed, [&](const string& token) { ammo->add_mats(token); }, mSettings->ammo.mats) && all; if (mSettings->ammo.other_mats.size() > 2) { - WARN(log).print("ammo other materials > 2: %zd\n", - mSettings->ammo.other_mats.size()); + WARN(log, out).print("ammo other materials > 2: %zd\n", + mPile->settings.ammo.other_mats.size()); } size_t num_other_mats = std::min(size_t(2), @@ -967,23 +985,23 @@ bool StockpileSettingsSerializer::write_ammo(StockpileSettings::AmmoSet* ammo) { } const string token = i == 0 ? "WOOD" : "BONE"; ammo->add_other_mats(token); - DEBUG(log).print("other mats %zd is %s\n", i, token.c_str()); + DEBUG(log, out).print("other mats %zd is %s\n", i, token.c_str()); } - all = serialize_list_quality( + all = serialize_list_quality(out, [&](const string& token) { ammo->add_quality_core(token); }, mSettings->ammo.quality_core) && all; - all = serialize_list_quality( + all = serialize_list_quality(out, [&](const string& token) { ammo->add_quality_total(token); }, mSettings->ammo.quality_total) && all; return all; } -void StockpileSettingsSerializer::read_ammo(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_ammo(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pammo = mSettings->ammo; - read_category("ammo", mode, + read_category(out, "ammo", mode, std::bind(&StockpileSettings::has_ammo, mBuffer), std::bind(&StockpileSettings::ammo, mBuffer), mSettings->flags.whole, @@ -998,18 +1016,18 @@ void StockpileSettingsSerializer::read_ammo(DeserializeMode mode, const vector const string& { return bammo.type(idx); }, bammo.type_size(), pammo.type, item_type::AMMO); - unserialize_list_material("mats", all, val, filters, ammo_mat_is_allowed, + unserialize_list_material(out, "mats", all, val, filters, ammo_mat_is_allowed, [&](const size_t& idx) -> const string& { return bammo.mats(idx); }, bammo.mats_size(), pammo.mats); pammo.other_mats.resize(2, '\0'); if (all) { - set_filter_elem("other", filters, val, "WOOD", 0, pammo.other_mats.at(0)); - set_filter_elem("other", filters, val, "BONE", 1, pammo.other_mats.at(1)); + set_filter_elem(out, "other", filters, val, "WOOD", 0, pammo.other_mats.at(0)); + set_filter_elem(out, "other", filters, val, "BONE", 1, pammo.other_mats.at(1)); } else { // TODO can we un-hardcode the values? for (int i = 0; i < bammo.other_mats_size(); ++i) { @@ -1017,35 +1035,35 @@ void StockpileSettingsSerializer::read_ammo(DeserializeMode mode, const vector const string& { return bammo.quality_core(idx); }, bammo.quality_core_size(), pammo.quality_core); - unserialize_list_quality("total", all, val, filters, + unserialize_list_quality(out, "total", all, val, filters, [&](const size_t& idx) -> const string& { return bammo.quality_total(idx); }, bammo.quality_total_size(), pammo.quality_total); }); } -bool StockpileSettingsSerializer::write_animals(StockpileSettings::AnimalsSet* animals) { +bool StockpileSettingsSerializer::write_animals(color_ostream& out, StockpileSettings::AnimalsSet* animals) { auto & panimals = mSettings->animals; bool all = panimals.empty_cages && panimals.empty_traps; animals->set_empty_cages(panimals.empty_cages); animals->set_empty_traps(panimals.empty_traps); - return serialize_list_creature( + return serialize_list_creature(out, [&](const string& token) { animals->add_enabled(token); }, panimals.enabled) && all; } -void StockpileSettingsSerializer::read_animals(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_animals(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & panimals = mSettings->animals; - read_category("animals", mode, + read_category(out, "animals", mode, std::bind(&StockpileSettings::has_animals, mBuffer), std::bind(&StockpileSettings::animals, mBuffer), mSettings->flags.whole, @@ -1058,10 +1076,10 @@ void StockpileSettingsSerializer::read_animals(DeserializeMode mode, const vecto [&](bool all, char val) { auto & banimals = mBuffer.animals(); - set_flag("cages", filters, all, val, banimals.empty_cages(), panimals.empty_cages); - set_flag("traps", filters, all, val, banimals.empty_traps(), panimals.empty_traps); + set_flag(out, "cages", filters, all, val, banimals.empty_cages(), panimals.empty_cages); + set_flag(out, "traps", filters, all, val, banimals.empty_traps(), panimals.empty_traps); - unserialize_list_creature("", all, val, filters, + unserialize_list_creature(out, "", all, val, filters, [&](const size_t& idx) -> const string& { return banimals.enabled(idx); }, banimals.enabled_size(), panimals.enabled); }); @@ -1071,7 +1089,7 @@ static bool armor_mat_is_allowed(const MaterialInfo& mi) { return mi.isValid() && mi.material && mi.material->flags.is_set(material_flags::IS_METAL); } -bool StockpileSettingsSerializer::write_armor(StockpileSettings::ArmorSet* armor) { +bool StockpileSettingsSerializer::write_armor(color_ostream& out, StockpileSettings::ArmorSet* armor) { auto & parmor = mSettings->armor; bool all = parmor.unusable && parmor.usable; @@ -1080,72 +1098,72 @@ bool StockpileSettingsSerializer::write_armor(StockpileSettings::ArmorSet* armor armor->set_usable(parmor.usable); // armor type - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { armor->add_body(token); }, parmor.body, vector(world->raws.itemdefs.armor.begin(), world->raws.itemdefs.armor.end()), item_type::ARMOR) && all; // helm type - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { armor->add_head(token); }, parmor.head, vector(world->raws.itemdefs.helms.begin(), world->raws.itemdefs.helms.end()), item_type::HELM) && all; // shoes type - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { armor->add_feet(token); }, parmor.feet, vector(world->raws.itemdefs.shoes.begin(), world->raws.itemdefs.shoes.end()), item_type::SHOES) && all; // gloves type - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { armor->add_hands(token); }, parmor.hands, vector(world->raws.itemdefs.gloves.begin(), world->raws.itemdefs.gloves.end()), item_type::GLOVES) && all; // pant type - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { armor->add_legs(token); }, parmor.legs, vector(world->raws.itemdefs.pants.begin(), world->raws.itemdefs.pants.end()), item_type::PANTS) && all; // shield type - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { armor->add_shield(token); }, parmor.shield, vector(world->raws.itemdefs.shields.begin(), world->raws.itemdefs.shields.end()), item_type::SHIELD) && all; // materials - all = serialize_list_material( + all = serialize_list_material(out, armor_mat_is_allowed, [&](const string& token) { armor->add_mats(token); }, parmor.mats) && all; // other mats - all = serialize_list_other_mats( + all = serialize_list_other_mats(out, mOtherMatsWeaponsArmor.mats, [&](const string& token) { armor->add_other_mats(token); }, parmor.other_mats) && all; // quality core - all = serialize_list_quality([&](const string& token) { armor->add_quality_core(token); }, + all = serialize_list_quality(out, [&](const string& token) { armor->add_quality_core(token); }, parmor.quality_core) && all; // quality total - all = serialize_list_quality([&](const string& token) { armor->add_quality_total(token); }, + all = serialize_list_quality(out, [&](const string& token) { armor->add_quality_total(token); }, parmor.quality_total) && all; return all; } -void StockpileSettingsSerializer::read_armor(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_armor(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & parmor = mSettings->armor; - read_category("armor", mode, + read_category(out, "armor", mode, std::bind(&StockpileSettings::has_armor, mBuffer), std::bind(&StockpileSettings::armor, mBuffer), mSettings->flags.whole, @@ -1167,47 +1185,47 @@ void StockpileSettingsSerializer::read_armor(DeserializeMode mode, const vector< [&](bool all, char val) { auto & barmor = mBuffer.armor(); - set_flag("nouse", filters, all, val, barmor.unusable(), parmor.unusable); - set_flag("canuse", filters, all, val, barmor.usable(), parmor.usable); + set_flag(out, "nouse", filters, all, val, barmor.unusable(), parmor.unusable); + set_flag(out, "canuse", filters, all, val, barmor.usable(), parmor.usable); - unserialize_list_itemdef("body", all, val, filters, + unserialize_list_itemdef(out, "body", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.body(idx); }, barmor.body_size(), parmor.body, item_type::ARMOR); - unserialize_list_itemdef("head", all, val, filters, + unserialize_list_itemdef(out, "head", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.head(idx); }, barmor.head_size(), parmor.head, item_type::HELM); - unserialize_list_itemdef("feet", all, val, filters, + unserialize_list_itemdef(out, "feet", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.feet(idx); }, barmor.feet_size(), parmor.feet, item_type::SHOES); - unserialize_list_itemdef("hands", all, val, filters, + unserialize_list_itemdef(out, "hands", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.hands(idx); }, barmor.hands_size(), parmor.hands, item_type::GLOVES); - unserialize_list_itemdef("legs", all, val, filters, + unserialize_list_itemdef(out, "legs", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.legs(idx); }, barmor.legs_size(), parmor.legs, item_type::PANTS); - unserialize_list_itemdef("shield", all, val, filters, + unserialize_list_itemdef(out, "shield", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.shield(idx); }, barmor.shield_size(), parmor.shield, item_type::SHIELD); - unserialize_list_material("mats", all, val, filters, + unserialize_list_material(out, "mats", all, val, filters, armor_mat_is_allowed, [&](const size_t& idx) -> const string& { return barmor.mats(idx); }, barmor.mats_size(), parmor.mats); - unserialize_list_other_mats("other", all, val, filters, + unserialize_list_other_mats(out, "other", all, val, filters, mOtherMatsWeaponsArmor.mats, [&](const size_t& idx) -> const string& { return barmor.other_mats(idx); }, barmor.other_mats_size(), parmor.other_mats); - unserialize_list_quality("core", all, val, filters, + unserialize_list_quality(out, "core", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.quality_core(idx); }, barmor.quality_core_size(), parmor.quality_core); - unserialize_list_quality("total", all, val, filters, + unserialize_list_quality(out, "total", all, val, filters, [&](const size_t& idx) -> const string& { return barmor.quality_total(idx); }, barmor.quality_total_size(), parmor.quality_total); }); @@ -1221,31 +1239,32 @@ static bool blocks_mat_is_allowed(const MaterialInfo& mi) { return mi.isValid() && mi.material && (mi.material->flags.is_set(material_flags::IS_METAL) || mi.material->flags.is_set(material_flags::IS_STONE)); } -bool StockpileSettingsSerializer::write_bars_blocks(StockpileSettings::BarsBlocksSet* bars_blocks) { - bool all = serialize_list_material( +bool StockpileSettingsSerializer::write_bars_blocks(color_ostream& out, StockpileSettings::BarsBlocksSet* bars_blocks) { + bool all = serialize_list_material(out, bars_mat_is_allowed, [&](const string& token) { bars_blocks->add_bars_mats(token); }, mSettings->bars_blocks.bars_mats); - all = serialize_list_material( + all = serialize_list_material(out, blocks_mat_is_allowed, [&](const string& token) { bars_blocks->add_blocks_mats(token); }, mSettings->bars_blocks.blocks_mats) && all; - all = serialize_list_other_mats( + all = serialize_list_other_mats(out, mOtherMatsBars.mats, [&](const string& token) { bars_blocks->add_bars_other_mats(token); }, mSettings->bars_blocks.bars_other_mats) && all; - all = serialize_list_other_mats( + all = serialize_list_other_mats(out, mOtherMatsBlocks.mats, [&](const string& token) { bars_blocks->add_blocks_other_mats(token); }, mSettings->bars_blocks.blocks_other_mats) && all; return all; } -void StockpileSettingsSerializer::read_bars_blocks(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_bars_blocks(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pbarsblocks = mSettings->bars_blocks; - read_category("bars_blocks", mode, + read_category(out, "bars_blocks", mode, +>>>>>>> 7a1aacdca (import and export logistics features) std::bind(&StockpileSettings::has_barsblocks, mBuffer), std::bind(&StockpileSettings::barsblocks, mBuffer), mSettings->flags.whole, @@ -1259,68 +1278,69 @@ void StockpileSettingsSerializer::read_bars_blocks(DeserializeMode mode, const v [&](bool all, char val) { auto & bbarsblocks = mBuffer.barsblocks(); - unserialize_list_material("mats/bars", all, val, filters, bars_mat_is_allowed, + unserialize_list_material(out, "mats/bars", all, val, filters, bars_mat_is_allowed, [&](const size_t& idx) -> const string& { return bbarsblocks.bars_mats(idx); }, bbarsblocks.bars_mats_size(), pbarsblocks.bars_mats); - unserialize_list_other_mats("other/bars", all, val, filters, + unserialize_list_other_mats(out, "other/bars", all, val, filters, mOtherMatsBars.mats, [&](const size_t& idx) -> const string& { return bbarsblocks.bars_other_mats(idx); }, bbarsblocks.bars_other_mats_size(), pbarsblocks.bars_other_mats); - unserialize_list_material("mats/blocks", all, val, filters, + unserialize_list_material(out, "mats/blocks", all, val, filters, blocks_mat_is_allowed, [&](const size_t& idx) -> const string& { return bbarsblocks.blocks_mats(idx); }, bbarsblocks.blocks_mats_size(), pbarsblocks.blocks_mats); - unserialize_list_other_mats("other/blocks", all, val, filters, + unserialize_list_other_mats(out, "other/blocks", all, val, filters, mOtherMatsBlocks.mats, [&](const size_t& idx) -> const string& { return bbarsblocks.blocks_other_mats(idx); }, bbarsblocks.blocks_other_mats_size(), pbarsblocks.blocks_other_mats); }); } -bool StockpileSettingsSerializer::write_cloth(StockpileSettings::ClothSet* cloth) { +bool StockpileSettingsSerializer::write_cloth(color_ostream& out, StockpileSettings::ClothSet* cloth) { bool all = true; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_thread_silk(token); }, &mSettings->cloth.thread_silk, organic_mat_category::Silk) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_thread_plant(token); }, &mSettings->cloth.thread_plant, organic_mat_category::PlantFiber) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_thread_yarn(token); }, &mSettings->cloth.thread_yarn, organic_mat_category::Yarn) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_thread_metal(token); }, &mSettings->cloth.thread_metal, organic_mat_category::MetalThread) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_cloth_silk(token); }, &mSettings->cloth.cloth_silk, organic_mat_category::Silk) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_cloth_plant(token); }, &mSettings->cloth.cloth_plant, organic_mat_category::PlantFiber) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_cloth_yarn(token); }, &mSettings->cloth.cloth_yarn, organic_mat_category::Yarn) && all; - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { cloth->add_cloth_metal(token); }, &mSettings->cloth.cloth_metal, organic_mat_category::MetalThread) && all; return all; } -void StockpileSettingsSerializer::read_cloth(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_cloth(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pcloth = mSettings->cloth; - read_category("cloth", mode, + read_category(out, "cloth", mode, +>>>>>>> 7a1aacdca (import and export logistics features) std::bind(&StockpileSettings::has_cloth, mBuffer), std::bind(&StockpileSettings::cloth, mBuffer), mSettings->flags.whole, @@ -1338,35 +1358,35 @@ void StockpileSettingsSerializer::read_cloth(DeserializeMode mode, const vector< [&](bool all, char val) { auto & bcloth = mBuffer.cloth(); - unserialize_list_organic_mat("thread/silk", all, val, filters, + unserialize_list_organic_mat(out, "thread/silk", all, val, filters, [&](size_t idx) -> string { return bcloth.thread_silk(idx); }, bcloth.thread_silk_size(), pcloth.thread_silk, organic_mat_category::Silk); - unserialize_list_organic_mat("thread/plant", all, val, filters, + unserialize_list_organic_mat(out, "thread/plant", all, val, filters, [&](size_t idx) -> string { return bcloth.thread_plant(idx); }, bcloth.thread_plant_size(), pcloth.thread_plant, organic_mat_category::PlantFiber); - unserialize_list_organic_mat("thread/yarn", all, val, filters, + unserialize_list_organic_mat(out, "thread/yarn", all, val, filters, [&](size_t idx) -> string { return bcloth.thread_yarn(idx); }, bcloth.thread_yarn_size(), pcloth.thread_yarn, organic_mat_category::Yarn); - unserialize_list_organic_mat("thread/metal", all, val, filters, + unserialize_list_organic_mat(out, "thread/metal", all, val, filters, [&](size_t idx) -> string { return bcloth.thread_metal(idx); }, bcloth.thread_metal_size(), pcloth.thread_metal, organic_mat_category::MetalThread); - unserialize_list_organic_mat("cloth/silk", all, val, filters, + unserialize_list_organic_mat(out, "cloth/silk", all, val, filters, [&](size_t idx) -> string { return bcloth.cloth_silk(idx); }, bcloth.cloth_silk_size(), pcloth.cloth_silk, organic_mat_category::Silk); - unserialize_list_organic_mat("cloth/plant", all, val, filters, + unserialize_list_organic_mat(out, "cloth/plant", all, val, filters, [&](size_t idx) -> string { return bcloth.cloth_plant(idx); }, bcloth.cloth_plant_size(), pcloth.cloth_plant, organic_mat_category::PlantFiber); - unserialize_list_organic_mat("cloth/yarn", all, val, filters, + unserialize_list_organic_mat(out, "cloth/yarn", all, val, filters, [&](size_t idx) -> string { return bcloth.cloth_yarn(idx); }, bcloth.cloth_yarn_size(), pcloth.cloth_yarn, organic_mat_category::Yarn); - unserialize_list_organic_mat("cloth/metal", all, val, filters, + unserialize_list_organic_mat(out, "cloth/metal", all, val, filters, [&](size_t idx) -> string { return bcloth.cloth_metal(idx); }, bcloth.cloth_metal_size(), pcloth.cloth_metal, organic_mat_category::MetalThread); }); @@ -1376,16 +1396,16 @@ static bool coins_mat_is_allowed(const MaterialInfo& mi) { return mi.isValid(); } -bool StockpileSettingsSerializer::write_coins(StockpileSettings::CoinSet* coins) { - return serialize_list_material( +bool StockpileSettingsSerializer::write_coins(color_ostream& out, StockpileSettings::CoinSet* coins) { + return serialize_list_material(out, coins_mat_is_allowed, [&](const string& token) { coins->add_mats(token); }, mSettings->coins.mats); } -void StockpileSettingsSerializer::read_coins(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_coins(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pcoins = mSettings->coins; - read_category("coin", mode, + read_category(out, "coin", mode, std::bind(&StockpileSettings::has_coin, mBuffer), std::bind(&StockpileSettings::coin, mBuffer), mSettings->flags.whole, @@ -1396,7 +1416,7 @@ void StockpileSettingsSerializer::read_coins(DeserializeMode mode, const vector< [&](bool all, char val) { auto & bcoin = mBuffer.coin(); - unserialize_list_material("", all, val, filters, coins_mat_is_allowed, + unserialize_list_material(out, "", all, val, filters, coins_mat_is_allowed, [&](const size_t& idx) -> const string& { return bcoin.mats(idx); }, bcoin.mats_size(), pcoins.mats); }); @@ -1439,33 +1459,33 @@ static bool finished_goods_mat_is_allowed(const MaterialInfo& mi) { return mi.isValid() && mi.material && (mi.material->flags.is_set(material_flags::IS_GEM) || mi.material->flags.is_set(material_flags::IS_METAL) || mi.material->flags.is_set(material_flags::IS_STONE)); } -bool StockpileSettingsSerializer::write_finished_goods(StockpileSettings::FinishedGoodsSet* finished_goods) { - bool all = serialize_list_item_type( +bool StockpileSettingsSerializer::write_finished_goods(color_ostream& out, StockpileSettings::FinishedGoodsSet* finished_goods) { + bool all = serialize_list_item_type(out, finished_goods_type_is_allowed, [&](const string& token) { finished_goods->add_type(token); }, mSettings->finished_goods.type); - all = serialize_list_material( + all = serialize_list_material(out, finished_goods_mat_is_allowed, [&](const string& token) { finished_goods->add_mats(token); }, mSettings->finished_goods.mats) && all; - all = serialize_list_other_mats( + all = serialize_list_other_mats(out, mOtherMatsFinishedGoods.mats, [&](const string& token) { finished_goods->add_other_mats(token); }, mSettings->finished_goods.other_mats) && all; - all = serialize_list_quality([&](const string& token) { finished_goods->add_quality_core(token); }, + all = serialize_list_quality([&](out, const string& token) { finished_goods->add_quality_core(token); }, mSettings->finished_goods.quality_core) && all; - all = serialize_list_quality([&](const string& token) { finished_goods->add_quality_total(token); }, + all = serialize_list_quality([&](out, const string& token) { finished_goods->add_quality_total(token); }, mSettings->finished_goods.quality_total) && all; return all; } -void StockpileSettingsSerializer::read_finished_goods(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_finished_goods(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pfinished_goods = mSettings->finished_goods; - read_category("finished_goods", mode, + read_category(out, "finished_goods", mode, std::bind(&StockpileSettings::has_finished_goods, mBuffer), std::bind(&StockpileSettings::finished_goods, mBuffer), mSettings->flags.whole, @@ -1480,23 +1500,23 @@ void StockpileSettingsSerializer::read_finished_goods(DeserializeMode mode, cons [&](bool all, char val) { auto & bfinished_goods = mBuffer.finished_goods(); - unserialize_list_item_type("type", all, val, filters, finished_goods_type_is_allowed, + unserialize_list_item_type(out, "type", all, val, filters, finished_goods_type_is_allowed, [&](const size_t& idx) -> const string& { return bfinished_goods.type(idx); }, bfinished_goods.type_size(), pfinished_goods.type); - unserialize_list_material("mats", all, val, filters, finished_goods_mat_is_allowed, + unserialize_list_material(out, "mats", all, val, filters, finished_goods_mat_is_allowed, [&](const size_t& idx) -> const string& { return bfinished_goods.mats(idx); }, bfinished_goods.mats_size(), pfinished_goods.mats); - unserialize_list_other_mats("other", all, val, filters, mOtherMatsFinishedGoods.mats, + unserialize_list_other_mats(out, "other", all, val, filters, mOtherMatsFinishedGoods.mats, [&](const size_t& idx) -> const string& { return bfinished_goods.other_mats(idx); }, bfinished_goods.other_mats_size(), pfinished_goods.other_mats); - unserialize_list_quality("core", all, val, filters, + unserialize_list_quality(out, "core", all, val, filters, [&](const size_t& idx) -> const string& { return bfinished_goods.quality_core(idx); }, bfinished_goods.quality_core_size(), pfinished_goods.quality_core); - unserialize_list_quality("total", all, val, filters, + unserialize_list_quality(out, "total", all, val, filters, [&](const size_t& idx) -> const string& { return bfinished_goods.quality_total(idx); }, bfinished_goods.quality_total_size(), pfinished_goods.quality_total); }); @@ -1684,7 +1704,7 @@ food_pair StockpileSettingsSerializer::food_map(organic_mat_category::organic_ma return food_pair(); } -bool StockpileSettingsSerializer::write_food(StockpileSettings::FoodSet* food) { +bool StockpileSettingsSerializer::write_food(color_ostream& out, StockpileSettings::FoodSet* food) { auto & pfood = mSettings->food; bool all = pfood.prepared_meals; @@ -1696,19 +1716,19 @@ bool StockpileSettingsSerializer::write_food(StockpileSettings::FoodSet* food) { food_pair p = food_map((organic_mat_category)mat_category); if (!p.valid) continue; - all = serialize_list_organic_mat(p.set_value, p.stockpile_values, + all = serialize_list_organic_mat(out, p.set_value, p.stockpile_values, (organic_mat_category)mat_category) && all; } return all; } -void StockpileSettingsSerializer::read_food(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_food(color_ostream& out, DeserializeMode mode, const vector& filters) { using df::enums::organic_mat_category::organic_mat_category; using traits = df::enum_traits; auto & pfood = mSettings->food; - read_category("food", mode, + read_category(out, "food", mode, std::bind(&StockpileSettings::has_food, mBuffer), std::bind(&StockpileSettings::food, mBuffer), mSettings->flags.whole, @@ -1725,25 +1745,24 @@ void StockpileSettingsSerializer::read_food(DeserializeMode mode, const vectorflags.is_set(material_flags::IS_METAL) || mi.material->flags.is_set(material_flags::IS_STONE)); } -bool StockpileSettingsSerializer::write_furniture(StockpileSettings::FurnitureSet* furniture) { +bool StockpileSettingsSerializer::write_furniture(color_ostream& out, StockpileSettings::FurnitureSet* furniture) { using df::enums::furniture_type::furniture_type; using type_traits = df::enum_traits; @@ -1757,30 +1776,30 @@ bool StockpileSettingsSerializer::write_furniture(StockpileSettings::FurnitureSe } string f_type(type_traits::key_table[i]); furniture->add_type(f_type); - DEBUG(log).print("furniture_type %zd is %s\n", i, f_type.c_str()); + DEBUG(log, out).print("furniture_type %zd is %s\n", i, f_type.c_str()); } - all = serialize_list_material( + all = serialize_list_material(out, furniture_mat_is_allowed, [&](const string& token) { furniture->add_mats(token); }, pfurniture.mats) && all; - all = serialize_list_other_mats( + all = serialize_list_other_mats(out, mOtherMatsFurniture.mats, [&](const string& token) { furniture->add_other_mats(token); }, pfurniture.other_mats) && all; - all = serialize_list_quality( + all = serialize_list_quality(out, [&](const string& token) { furniture->add_quality_core(token); }, pfurniture.quality_core) && all; - all = serialize_list_quality( + all = serialize_list_quality(out, [&](const string& token) { furniture->add_quality_total(token); }, pfurniture.quality_total) && all; return all; } -void StockpileSettingsSerializer::read_furniture(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_furniture(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pfurniture = mSettings->furniture; - read_category("furniture", mode, + read_category(out, "furniture", mode, std::bind(&StockpileSettings::has_furniture, mBuffer), std::bind(&StockpileSettings::furniture, mBuffer), mSettings->flags.whole, @@ -1803,33 +1822,33 @@ void StockpileSettingsSerializer::read_furniture(DeserializeMode mode, const vec if (all) { for (size_t idx = 0; idx < num_elems; ++idx) { string id = ENUM_KEY_STR(furniture_type, (df::furniture_type)idx); - set_filter_elem("type", filters, val, id, idx, pfurniture.type.at(idx)); + set_filter_elem(out, "type", filters, val, id, idx, pfurniture.type.at(idx)); } } else { for (int i = 0; i < bfurniture.type_size(); ++i) { const string token = bfurniture.type(i); df::enum_traits::base_type idx = linear_index(type_traits, token); if (idx < 0 || size_t(idx) >= pfurniture.type.size()) { - WARN(log).print("furniture type index invalid %s, idx=%d\n", token.c_str(), idx); + WARN(log, out).print("furniture type index invalid %s, idx=%d\n", token.c_str(), idx); continue; } - set_filter_elem("type", filters, val, token, idx, pfurniture.type.at(idx)); + set_filter_elem(out, "type", filters, val, token, idx, pfurniture.type.at(idx)); } } - unserialize_list_material("mats", all, val, filters, furniture_mat_is_allowed, + unserialize_list_material(out, "mats", all, val, filters, furniture_mat_is_allowed, [&](const size_t& idx) -> const string& { return bfurniture.mats(idx); }, bfurniture.mats_size(), pfurniture.mats); - unserialize_list_other_mats("other", all, val, filters, + unserialize_list_other_mats(out, "other", all, val, filters, mOtherMatsFurniture.mats, [&](const size_t& idx) -> const string& { return bfurniture.other_mats(idx); }, bfurniture.other_mats_size(), pfurniture.other_mats); - unserialize_list_quality("core", all, val, filters, + unserialize_list_quality(out, "core", all, val, filters, [&](const size_t& idx) -> const string& { return bfurniture.quality_core(idx); }, bfurniture.quality_core_size(), pfurniture.quality_core); - unserialize_list_quality("total", all, val, filters, + unserialize_list_quality(out, "total", all, val, filters, [&](const size_t& idx) -> const string& { return bfurniture.quality_total(idx); }, bfurniture.quality_total_size(), pfurniture.quality_total); }); @@ -1847,17 +1866,17 @@ static bool gem_other_mat_is_allowed(MaterialInfo& mi) { return mi.isValid() && (mi.getToken() == "GLASS_GREEN" || mi.getToken() == "GLASS_CLEAR" || mi.getToken() == "GLASS_CRYSTAL"); } -bool StockpileSettingsSerializer::write_gems(StockpileSettings::GemsSet* gems) { +bool StockpileSettingsSerializer::write_gems(color_ostream& out, StockpileSettings::GemsSet* gems) { MaterialInfo mi; auto & pgems = mSettings->gems; - bool all = serialize_list_material( + bool all = serialize_list_material(out, gem_mat_is_allowed, [&](const string& token) { gems->add_rough_mats(token); }, pgems.rough_mats); - all = serialize_list_material( + all = serialize_list_material(out, gem_cut_mat_is_allowed, [&](const string& token) { gems->add_cut_mats(token); }, pgems.cut_mats) && all; @@ -1870,7 +1889,7 @@ bool StockpileSettingsSerializer::write_gems(StockpileSettings::GemsSet* gems) { mi.decode(i, -1); if (!gem_other_mat_is_allowed(mi)) continue; - DEBUG(log).print("gem rough_other mat %zd is %s\n", i, mi.getToken().c_str()); + DEBUG(log, out).print("gem rough_other mat %zd is %s\n", i, mi.getToken().c_str()); gems->add_rough_other_mats(mi.getToken()); } @@ -1884,16 +1903,16 @@ bool StockpileSettingsSerializer::write_gems(StockpileSettings::GemsSet* gems) { mi.decode(0, i); if (!gem_other_mat_is_allowed(mi)) continue; - DEBUG(log).print("gem cut_other mat %zd is %s\n", i, mi.getToken().c_str()); + DEBUG(log, out).print("gem cut_other mat %zd is %s\n", i, mi.getToken().c_str()); gems->add_cut_other_mats(mi.getToken()); } return all; } -void StockpileSettingsSerializer::read_gems(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_gems(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pgems = mSettings->gems; - read_category("gems", mode, + read_category(out, "gems", mode, std::bind(&StockpileSettings::has_gems, mBuffer), std::bind(&StockpileSettings::gems, mBuffer), mSettings->flags.whole, @@ -1907,11 +1926,11 @@ void StockpileSettingsSerializer::read_gems(DeserializeMode mode, const vector const string& { return bgems.rough_mats(idx); }, bgems.rough_mats_size(), pgems.rough_mats); - unserialize_list_material("mats/cut", all, val, filters, gem_cut_mat_is_allowed, + unserialize_list_material(out, "mats/cut", all, val, filters, gem_cut_mat_is_allowed, [&](const size_t& idx) -> const string& { return bgems.cut_mats(idx); }, bgems.cut_mats_size(), pgems.cut_mats); @@ -1923,11 +1942,11 @@ void StockpileSettingsSerializer::read_gems(DeserializeMode mode, const vectoradd_mats(id); }, &mSettings->leather.mats, organic_mat_category::Leather); } -void StockpileSettingsSerializer::read_leather(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_leather(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pleather = mSettings->leather; - read_category("leather", mode, + read_category(out, "leather", mode, std::bind(&StockpileSettings::has_leather, mBuffer), std::bind(&StockpileSettings::leather, mBuffer), mSettings->flags.whole, @@ -1967,21 +1986,21 @@ void StockpileSettingsSerializer::read_leather(DeserializeMode mode, const vecto [&](bool all, char val) { auto & bleather = mBuffer.leather(); - unserialize_list_organic_mat("", all, val, filters, + unserialize_list_organic_mat(out, "", all, val, filters, [&](size_t idx) -> string { return bleather.mats(idx); }, bleather.mats_size(), pleather.mats, organic_mat_category::Leather); }); } -bool StockpileSettingsSerializer::write_corpses(StockpileSettings::CorpsesSet* corpses) { - return serialize_list_creature( +bool StockpileSettingsSerializer::write_corpses(color_ostream& out, StockpileSettings::CorpsesSet* corpses) { + return serialize_list_creature(out, [&](const string& token) { corpses->add_corpses(token); }, mSettings->corpses.corpses); } -void StockpileSettingsSerializer::read_corpses(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_corpses(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pcorpses = mSettings->corpses; - read_category("corpses", mode, + read_category(out, "corpses", mode, std::bind(&StockpileSettings::has_corpses_v50, mBuffer), std::bind(&StockpileSettings::corpses_v50, mBuffer), mSettings->flags.whole, @@ -1991,7 +2010,7 @@ void StockpileSettingsSerializer::read_corpses(DeserializeMode mode, const vecto }, [&](bool all, char val) { auto & bcorpses = mBuffer.corpses_v50(); - unserialize_list_creature("", all, val, filters, + unserialize_list_creature(out, "", all, val, filters, [&](const size_t& idx) -> const string& { return bcorpses.corpses(idx); }, bcorpses.corpses_size(), pcorpses.corpses); }); @@ -2006,48 +2025,48 @@ static bool refuse_type_is_allowed(item_type::item_type type) { return true; } -bool StockpileSettingsSerializer::write_refuse(StockpileSettings::RefuseSet* refuse) { +bool StockpileSettingsSerializer::write_refuse(color_ostream& out, StockpileSettings::RefuseSet* refuse) { auto & prefuse = mSettings->refuse; bool all = prefuse.fresh_raw_hide && prefuse.rotten_raw_hide; refuse->set_fresh_raw_hide(prefuse.fresh_raw_hide); refuse->set_rotten_raw_hide(prefuse.rotten_raw_hide); - all = serialize_list_item_type(refuse_type_is_allowed, + all = serialize_list_item_type(out, refuse_type_is_allowed, [&](const string& token) { refuse->add_type(token); }, prefuse.type) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_corpses(token); }, prefuse.corpses) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_body_parts(token); }, prefuse.body_parts) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_skulls(token); }, prefuse.skulls) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_bones(token); }, prefuse.bones) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_hair(token); }, prefuse.hair) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_shells(token); }, prefuse.shells) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_teeth(token); }, prefuse.teeth) && all; - all = serialize_list_creature( + all = serialize_list_creature(out, [&](const string& token) { refuse->add_horns(token); }, prefuse.horns) && all; return all; } -void StockpileSettingsSerializer::read_refuse(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_refuse(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & prefuse = mSettings->refuse; - read_category("refuse", mode, + read_category(out, "refuse", mode, std::bind(&StockpileSettings::has_refuse, mBuffer), std::bind(&StockpileSettings::refuse, mBuffer), mSettings->flags.whole, @@ -2068,56 +2087,56 @@ void StockpileSettingsSerializer::read_refuse(DeserializeMode mode, const vector [&](bool all, char val) { auto & brefuse = mBuffer.refuse(); - set_flag("rawhide/fresh", filters, all, val, brefuse.fresh_raw_hide(), prefuse.fresh_raw_hide); - set_flag("rawhide/rotten", filters, all, val, brefuse.rotten_raw_hide(), prefuse.rotten_raw_hide); + set_flag(out, "rawhide/fresh", filters, all, val, brefuse.fresh_raw_hide(), prefuse.fresh_raw_hide); + set_flag(out, "rawhide/rotten", filters, all, val, brefuse.rotten_raw_hide(), prefuse.rotten_raw_hide); - unserialize_list_item_type("type", all, val, filters, refuse_type_is_allowed, + unserialize_list_item_type(out, "type", all, val, filters, refuse_type_is_allowed, [&](const size_t& idx) -> const string& { return brefuse.type(idx); }, brefuse.type_size(), prefuse.type); - unserialize_list_creature("corpses", all, val, filters, + unserialize_list_creature(out, "corpses", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.corpses(idx); }, brefuse.corpses_size(), prefuse.corpses); - unserialize_list_creature("bodyparts", all, val, filters, + unserialize_list_creature(out, "bodyparts", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.body_parts(idx); }, brefuse.body_parts_size(), prefuse.body_parts); - unserialize_list_creature("skulls", all, val, filters, + unserialize_list_creature(out, "skulls", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.skulls(idx); }, brefuse.skulls_size(), prefuse.skulls); - unserialize_list_creature("bones", all, val, filters, + unserialize_list_creature(out, "bones", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.bones(idx); }, brefuse.bones_size(), prefuse.bones); - unserialize_list_creature("hair", all, val, filters, + unserialize_list_creature(out, "hair", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.hair(idx); }, brefuse.hair_size(), prefuse.hair); - unserialize_list_creature("shells", all, val, filters, + unserialize_list_creature(out, "shells", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.shells(idx); }, brefuse.shells_size(), prefuse.shells); - unserialize_list_creature("teeth", all, val, filters, + unserialize_list_creature(out, "teeth", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.teeth(idx); }, brefuse.teeth_size(), prefuse.teeth); - unserialize_list_creature("horns", all, val, filters, + unserialize_list_creature(out, "horns", all, val, filters, [&](const size_t& idx) -> const string& { return brefuse.horns(idx); }, brefuse.horns_size(), prefuse.horns); }); } -bool StockpileSettingsSerializer::write_sheet(StockpileSettings::SheetSet* sheet) { - bool all = serialize_list_organic_mat( +bool StockpileSettingsSerializer::write_sheet(color_ostream& out, StockpileSettings::SheetSet* sheet) { + bool all = serialize_list_organic_mat(out, [&](const string& token) { sheet->add_paper(token); }, &mSettings->sheet.paper, organic_mat_category::Paper); - all = serialize_list_organic_mat( + all = serialize_list_organic_mat(out, [&](const string& token) { sheet->add_parchment(token); }, &mSettings->sheet.parchment, organic_mat_category::Parchment) && all; return all; } -void StockpileSettingsSerializer::read_sheet(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_sheet(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & psheet = mSettings->sheet; - read_category("sheet", mode, + read_category(out, "sheet", mode, std::bind(&StockpileSettings::has_sheet, mBuffer), std::bind(&StockpileSettings::sheet, mBuffer), mSettings->flags.whole, @@ -2129,11 +2148,11 @@ void StockpileSettingsSerializer::read_sheet(DeserializeMode mode, const vector< [&](bool all, char val) { auto & bsheet = mBuffer.sheet(); - unserialize_list_organic_mat("paper", all, val, filters, + unserialize_list_organic_mat(out, "paper", all, val, filters, [&](size_t idx) -> string { return bsheet.paper(idx); }, bsheet.paper_size(), psheet.paper, organic_mat_category::Paper); - unserialize_list_organic_mat("parchment", all, val, filters, + unserialize_list_organic_mat(out, "parchment", all, val, filters, [&](size_t idx) -> string { return bsheet.parchment(idx); }, bsheet.parchment_size(), psheet.parchment, organic_mat_category::Parchment); }); @@ -2147,16 +2166,16 @@ static bool stone_is_allowed(const MaterialInfo& mi) { return is_allowed_soil || is_allowed_stone; } -bool StockpileSettingsSerializer::write_stone(StockpileSettings::StoneSet* stone) { - return serialize_list_material( +bool StockpileSettingsSerializer::write_stone(color_ostream& out, StockpileSettings::StoneSet* stone) { + return serialize_list_material(out, stone_is_allowed, [&](const string& token) { stone->add_mats(token); }, mSettings->stone.mats); } -void StockpileSettingsSerializer::read_stone(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_stone(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pstone = mSettings->stone; - read_category("stone", mode, + read_category(out, "stone", mode, std::bind(&StockpileSettings::has_stone, mBuffer), std::bind(&StockpileSettings::stone, mBuffer), mSettings->flags.whole, @@ -2167,7 +2186,7 @@ void StockpileSettingsSerializer::read_stone(DeserializeMode mode, const vector< [&](bool all, char val) { auto & bstone = mBuffer.stone(); - unserialize_list_material("", all, val, filters, stone_is_allowed, + unserialize_list_material(out, "", all, val, filters, stone_is_allowed, [&](const size_t& idx) -> const string& { return bstone.mats(idx); }, bstone.mats_size(), pstone.mats); }); @@ -2177,49 +2196,49 @@ static bool weapons_mat_is_allowed(const MaterialInfo& mi) { return mi.isValid() && mi.material && (mi.material->flags.is_set(material_flags::IS_METAL) || mi.material->flags.is_set(material_flags::IS_STONE)); } -bool StockpileSettingsSerializer::write_weapons(StockpileSettings::WeaponsSet* weapons) { +bool StockpileSettingsSerializer::write_weapons(color_ostream& out, StockpileSettings::WeaponsSet* weapons) { auto & pweapons = mSettings->weapons; bool all = pweapons.unusable && pweapons.usable; weapons->set_unusable(pweapons.unusable); weapons->set_usable(pweapons.usable); - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { weapons->add_weapon_type(token); }, pweapons.weapon_type, vector(world->raws.itemdefs.weapons.begin(), world->raws.itemdefs.weapons.end()), item_type::WEAPON) && all; - all = serialize_list_itemdef( + all = serialize_list_itemdef(out, [&](const string& token) { weapons->add_trapcomp_type(token); }, pweapons.trapcomp_type, vector(world->raws.itemdefs.trapcomps.begin(), world->raws.itemdefs.trapcomps.end()), item_type::TRAPCOMP) && all; - all = serialize_list_material( + all = serialize_list_material(out, weapons_mat_is_allowed, [&](const string& token) { weapons->add_mats(token); }, pweapons.mats) && all; - all = serialize_list_other_mats( + all = serialize_list_other_mats(out, mOtherMatsWeaponsArmor.mats, [&](const string& token) { weapons->add_other_mats(token); }, pweapons.other_mats) && all; - all = serialize_list_quality( + all = serialize_list_quality(out, [&](const string& token) { weapons->add_quality_core(token); }, pweapons.quality_core) && all; - all = serialize_list_quality( + all = serialize_list_quality(out, [&](const string& token) { weapons->add_quality_total(token); }, pweapons.quality_total) && all; return all; } -void StockpileSettingsSerializer::read_weapons(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_weapons(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pweapons = mSettings->weapons; - read_category("weapons", mode, + read_category(out, "weapons", mode, std::bind(&StockpileSettings::has_weapons, mBuffer), std::bind(&StockpileSettings::weapons, mBuffer), mSettings->flags.whole, @@ -2237,30 +2256,30 @@ void StockpileSettingsSerializer::read_weapons(DeserializeMode mode, const vecto [&](bool all, char val) { auto & bweapons = mBuffer.weapons(); - set_flag("nouse", filters, all, val, bweapons.unusable(), pweapons.unusable); - set_flag("canuse", filters, all, val, bweapons.usable(), pweapons.usable); + set_flag(out, "nouse", filters, all, val, bweapons.unusable(), pweapons.unusable); + set_flag(out, "canuse", filters, all, val, bweapons.usable(), pweapons.usable); - unserialize_list_itemdef("type/weapon", all, val, filters, + unserialize_list_itemdef(out, "type/weapon", all, val, filters, [&](const size_t& idx) -> const string& { return bweapons.weapon_type(idx); }, bweapons.weapon_type_size(), pweapons.weapon_type, item_type::WEAPON); - unserialize_list_itemdef("type/trapcomp", all, val, filters, + unserialize_list_itemdef(out, "type/trapcomp", all, val, filters, [&](const size_t& idx) -> const string& { return bweapons.trapcomp_type(idx); }, bweapons.trapcomp_type_size(), pweapons.trapcomp_type, item_type::TRAPCOMP); - unserialize_list_material("mats", all, val, filters, weapons_mat_is_allowed, + unserialize_list_material(out, "mats", all, val, filters, weapons_mat_is_allowed, [&](const size_t& idx) -> const string& { return bweapons.mats(idx); }, bweapons.mats_size(), pweapons.mats); - unserialize_list_other_mats("other", all, val, filters, mOtherMatsWeaponsArmor.mats, + unserialize_list_other_mats(out, "other", all, val, filters, mOtherMatsWeaponsArmor.mats, [&](const size_t& idx) -> const string& { return bweapons.other_mats(idx); }, bweapons.other_mats_size(), pweapons.other_mats); - unserialize_list_quality("core", all, val, filters, + unserialize_list_quality(out, "core", all, val, filters, [&](const size_t& idx) -> const string& { return bweapons.quality_core(idx); }, bweapons.quality_core_size(), pweapons.quality_core); - unserialize_list_quality("total", all, val, filters, + unserialize_list_quality(out, "total", all, val, filters, [&](const size_t& idx) -> const string& { return bweapons.quality_total(idx); }, bweapons.quality_total_size(), pweapons.quality_total); }); @@ -2270,7 +2289,7 @@ static bool wood_mat_is_allowed(const df::plant_raw* plant) { return plant && plant->flags.is_set(plant_raw_flags::TREE); } -bool StockpileSettingsSerializer::write_wood(StockpileSettings::WoodSet* wood) { +bool StockpileSettingsSerializer::write_wood(color_ostream& out, StockpileSettings::WoodSet* wood) { bool all = true; for (size_t i = 0; i < mSettings->wood.mats.size(); ++i) { if (!mSettings->wood.mats.at(i)) { @@ -2281,14 +2300,14 @@ bool StockpileSettingsSerializer::write_wood(StockpileSettings::WoodSet* wood) { if (!wood_mat_is_allowed(plant)) continue; wood->add_mats(plant->id); - DEBUG(log).print("plant %zd is %s\n", i, plant->id.c_str()); + DEBUG(log, out).print("plant %zd is %s\n", i, plant->id.c_str()); } return all; } -void StockpileSettingsSerializer::read_wood(DeserializeMode mode, const vector& filters) { +void StockpileSettingsSerializer::read_wood(color_ostream& out, DeserializeMode mode, const vector& filters) { auto & pwood = mSettings->wood; - read_category("wood", mode, + read_category(out, "wood", mode, std::bind(&StockpileSettings::has_wood, mBuffer), std::bind(&StockpileSettings::wood, mBuffer), mSettings->flags.whole, @@ -2305,17 +2324,17 @@ void StockpileSettingsSerializer::read_wood(DeserializeMode mode, const vectorraws.plants.all[idx]->id; - set_filter_elem("", filters, val, id, idx, pwood.mats.at(idx)); + set_filter_elem(out, "", filters, val, id, idx, pwood.mats.at(idx)); } } else { for (int i = 0; i < bwood.mats_size(); ++i) { const string token = bwood.mats(i); const size_t idx = find_plant(token); if (idx < 0 || (size_t)idx >= num_elems) { - WARN(log).print("wood mat index invalid %s idx=%zd\n", token.c_str(), idx); + WARN(log, out).print("wood mat index invalid %s idx=%zd\n", token.c_str(), idx); continue; } - set_filter_elem("", filters, val, token, idx, pwood.mats.at(idx)); + set_filter_elem(out, "", filters, val, token, idx, pwood.mats.at(idx)); } } }); diff --git a/plugins/stockpiles/StockpileSerializer.h b/plugins/stockpiles/StockpileSerializer.h index f8d122ac2..115b21c9f 100644 --- a/plugins/stockpiles/StockpileSerializer.h +++ b/plugins/stockpiles/StockpileSerializer.h @@ -72,13 +72,13 @@ public: * Since we depend on protobuf-lite, not the full lib, we copy this function from * protobuf message.cc */ - bool serialize_to_ostream(std::ostream* output, uint32_t includedElements); + bool serialize_to_ostream(DFHack::color_ostream& out, std::ostream* output, uint32_t includedElements); /** * Will serialize stockpile settings to a file (overwrites existing files) * @return success/failure */ - bool serialize_to_file(const std::string& file, uint32_t includedElements); + bool serialize_to_file(DFHack::color_ostream& out, const std::string& file, uint32_t includedElements); /** * Again, copied from message.cc @@ -94,7 +94,7 @@ protected: dfstockpiles::StockpileSettings mBuffer; // read memory structures and serialize to protobuf - virtual void write(uint32_t includedElements); + virtual void write(DFHack::color_ostream& out, uint32_t includedElements); // parse serialized data into ui indices virtual void read(DeserializeMode mode, const std::vector& filters); @@ -105,41 +105,41 @@ protected: private: df::stockpile_settings *mSettings; - bool write_ammo(dfstockpiles::StockpileSettings::AmmoSet* ammo); - void read_ammo(DeserializeMode mode, const std::vector& filters); - bool write_animals(dfstockpiles::StockpileSettings::AnimalsSet* animals); - void read_animals(DeserializeMode mode, const std::vector& filters); - bool write_armor(dfstockpiles::StockpileSettings::ArmorSet* armor); - void read_armor(DeserializeMode mode, const std::vector& filters); - bool write_bars_blocks(dfstockpiles::StockpileSettings::BarsBlocksSet* bars_blocks); - void read_bars_blocks(DeserializeMode mode, const std::vector& filters); - bool write_cloth(dfstockpiles::StockpileSettings::ClothSet* cloth); - void read_cloth(DeserializeMode mode, const std::vector& filters); - bool write_coins(dfstockpiles::StockpileSettings::CoinSet* coins); - void read_coins(DeserializeMode mode, const std::vector& filters); - bool write_finished_goods(dfstockpiles::StockpileSettings::FinishedGoodsSet* finished_goods); - void read_finished_goods(DeserializeMode mode, const std::vector& filters); + bool write_ammo(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::AmmoSet* ammo); + void read_ammo(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_animals(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::AnimalsSet* animals); + void read_animals(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_armor(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::ArmorSet* armor); + void read_armor(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_bars_blocks(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::BarsBlocksSet* bars_blocks); + void read_bars_blocks(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_cloth(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::ClothSet* cloth); + void read_cloth(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_coins(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::CoinSet* coins); + void read_coins(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_finished_goods(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::FinishedGoodsSet* finished_goods); + void read_finished_goods(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); food_pair food_map(df::enums::organic_mat_category::organic_mat_category cat); - bool write_food(dfstockpiles::StockpileSettings::FoodSet* food); - void read_food(DeserializeMode mode, const std::vector& filters); - bool write_furniture(dfstockpiles::StockpileSettings::FurnitureSet* furniture); - void read_furniture(DeserializeMode mode, const std::vector& filters); - bool write_gems(dfstockpiles::StockpileSettings::GemsSet* gems); - void read_gems(DeserializeMode mode, const std::vector& filters); - bool write_leather(dfstockpiles::StockpileSettings::LeatherSet* leather); - void read_leather(DeserializeMode mode, const std::vector& filters); - bool write_corpses(dfstockpiles::StockpileSettings::CorpsesSet* corpses); - void read_corpses(DeserializeMode mode, const std::vector& filters); - bool write_refuse(dfstockpiles::StockpileSettings::RefuseSet* refuse); - void read_refuse(DeserializeMode mode, const std::vector& filters); - bool write_sheet(dfstockpiles::StockpileSettings::SheetSet* sheet); - void read_sheet(DeserializeMode mode, const std::vector& filters); - bool write_stone(dfstockpiles::StockpileSettings::StoneSet* stone); - void read_stone(DeserializeMode mode, const std::vector& filters); - bool write_weapons(dfstockpiles::StockpileSettings::WeaponsSet* weapons); - void read_weapons(DeserializeMode mode, const std::vector& filters); - bool write_wood(dfstockpiles::StockpileSettings::WoodSet* wood); - void read_wood(DeserializeMode mode, const std::vector& filters); + bool write_food(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::FoodSet* food); + void read_food(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_furniture(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::FurnitureSet* furniture); + void read_furniture(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_gems(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::GemsSet* gems); + void read_gems(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_leather(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::LeatherSet* leather); + void read_leather(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_corpses(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::CorpsesSet* corpses); + void read_corpses(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_refuse(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::RefuseSet* refuse); + void read_refuse(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_sheet(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::SheetSet* sheet); + void read_sheet(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_stone(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::StoneSet* stone); + void read_stone(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_weapons(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::WeaponsSet* weapons); + void read_weapons(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); + bool write_wood(DFHack::color_ostream& out, dfstockpiles::StockpileSettings::WoodSet* wood); + void read_wood(DFHack::color_ostream& out, DeserializeMode mode, const std::vector& filters); }; /** @@ -169,6 +169,6 @@ private: void write_containers(); void read_containers(DeserializeMode mode); - void write_features(); - void read_features(DeserializeMode mode); + void write_features(DFHack::color_ostream& out); + void read_features(DFHack::color_ostream &out, DeserializeMode mode); }; diff --git a/plugins/stockpiles/StockpileUtils.h b/plugins/stockpiles/StockpileUtils.h index 7dcd8c3a2..e78ffccd8 100644 --- a/plugins/stockpiles/StockpileUtils.h +++ b/plugins/stockpiles/StockpileUtils.h @@ -1,5 +1,6 @@ #pragma once +#include "LuaTools.h" #include "MiscUtils.h" #include "df/world.h" @@ -9,6 +10,11 @@ // Utility Functions {{{ // A set of convenience functions for doing common lookups +bool call_stockpiles_lua(DFHack::color_ostream* out, const char* fn_name, + int nargs = 0, int nres = 0, + DFHack::Lua::LuaLambda&& args_lambda = DFHack::Lua::DEFAULT_LUA_LAMBDA, + DFHack::Lua::LuaLambda&& res_lambda = DFHack::Lua::DEFAULT_LUA_LAMBDA); + /** * Retrieve creature raw from index */ diff --git a/plugins/stockpiles/stockpiles.cpp b/plugins/stockpiles/stockpiles.cpp index a289337a9..b9d6e9d37 100644 --- a/plugins/stockpiles/stockpiles.cpp +++ b/plugins/stockpiles/stockpiles.cpp @@ -38,10 +38,9 @@ DFhackCExport command_result plugin_init(color_ostream &out, vector