const std::map<int, string> mats;

OtherMatsFurniture() : mats(getMats()) {}

std::map<int, string> getMats() {

std::map<int, string> ret;

ret.emplace(0, "WOOD");

ret.emplace(1, "PLANT_CLOTH");

ret.emplace(2, "BONE");

ret.emplace(3, "TOOTH");

ret.emplace(4, "HORN");

ret.emplace(5, "PEARL");

ret.emplace(6, "SHELL");

ret.emplace(7, "LEATHER");

ret.emplace(8, "SILK");

ret.emplace(9, "AMBER");

ret.emplace(10, "CORAL");

ret.emplace(11, "GREEN_GLASS");

ret.emplace(12, "CLEAR_GLASS");

ret.emplace(13, "CRYSTAL_GLASS");

ret.emplace(14, "YARN");

return ret;

}

const std::map<int, string> mats;

OtherMatsBars() : mats(getMats()) {}

std::map<int, string> getMats() {

std::map<int, string> ret;

ret.emplace(0, "COAL");

ret.emplace(1, "POTASH");

ret.emplace(2, "ASH");

ret.emplace(3, "PEARLASH");

ret.emplace(4, "SOAP");

return ret;

}

const std::map<int, string> mats;

OtherMatsBlocks() : mats(getMats()) {}

std::map<int, string> getMats() {

std::map<int, string> ret;

ret.emplace(0, "GREEN_GLASS");

ret.emplace(1, "CLEAR_GLASS");

ret.emplace(2, "CRYSTAL_GLASS");

ret.emplace(3, "WOOD");

return ret;

}

const std::map<int, string> mats;

OtherMatsFinishedGoods() : mats(getMats()) {}

std::map<int, string> getMats() {

std::map<int, string> ret;

ret.emplace(0, "WOOD");

ret.emplace(1, "PLANT_CLOTH");

ret.emplace(2, "BONE");

ret.emplace(3, "TOOTH");

ret.emplace(4, "HORN");

ret.emplace(5, "PEARL");

ret.emplace(6, "SHELL");

ret.emplace(7, "LEATHER");

ret.emplace(8, "SILK");

ret.emplace(9, "AMBER");

ret.emplace(10, "CORAL");

ret.emplace(11, "GREEN_GLASS");

ret.emplace(12, "CLEAR_GLASS");

ret.emplace(13, "CRYSTAL_GLASS");

ret.emplace(14, "YARN");

ret.emplace(15, "WAX");

return ret;

}

const std::map<int, string> mats;

OtherMatsWeaponsArmor() : mats(getMats()) {}

std::map<int, string> getMats() {

std::map<int, string> ret;

ret.emplace(0, "WOOD");

ret.emplace(1, "PLANT_CLOTH");

ret.emplace(2, "BONE");

ret.emplace(3, "SHELL");

ret.emplace(4, "LEATHER");

ret.emplace(5, "SILK");

ret.emplace(6, "GREEN_GLASS");

ret.emplace(7, "CLEAR_GLASS");

ret.emplace(8, "CRYSTAL_GLASS");

ret.emplace(9, "YARN");

return ret;

}

if (output->fail())

return false;

mBuffer.Clear();

write(out, includedElements);

{

io::OstreamOutputStream zero_copy_output(output);

if (!mBuffer.SerializeToZeroCopyStream(&zero_copy_output))

return false;

}

return output->good();

std::fstream output(file, std::ios::out | std::ios::binary | std::ios::trunc);

if (output.fail()) {

WARN(log, out).print("ERROR: failed to open file for writing: '{}'\n",

file);

return false;

}

return serialize_to_ostream(out, &output, includedElements);

if (input->fail())

return false;

mBuffer.Clear();

io::IstreamInputStream zero_copy_input(input);

const bool res = mBuffer.ParseFromZeroCopyStream(&zero_copy_input)

&& input->eof();

if (res)

read(out, mode, filters);

return res;

std::fstream input(file, std::ios::in | std::ios::binary);

if (input.fail()) {

WARN(log, out).print("failed to open file for reading: '{}'\n",

file);

return false;

}

return parse_from_istream(out, &input, mode, filters);

E val;

if (!find_enum_item(&val, token))

return -1;

return val;

for (auto & filter : filters) {

DEBUG(log, out).print("searching for '{}' in '{}'\n", filter, name);

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())

return true;

}

return !filters.size();

if ((all || enabled) && matches_filter(out, filters, name)) {

DEBUG(log, out).print("setting {} to {}\n", name, val);

elem = val;

}

const string& name, const string& id, char& elem) {

if (matches_filter(out, filters, subcat + ((*subcat ? "/" : "") + name))) {

DEBUG(log, out).print("setting {} ({}) to {}\n", name, id, val);

elem = val;

}

const string& name, T_id id, T_val& elem) {

if (matches_filter(out, filters, subcat + ((*subcat ? "/" : "") + name))) {

DEBUG(log, out).print("setting {} ({}) to {}\n", name, id, val);

elem = val;

}

vector<char> list,

vector<df::itemdef*> items,

item_type::item_type type) {

bool all = true;

for (size_t i = 0; i < list.size(); ++i) {

if (!list.at(i)) {

all = false;

continue;

}

const df::itemdef* a = items.at(i);

// skip procedurally generated items

if (a->base_flags.is_set(df::itemdef_flags::GENERATED))

continue;

ItemTypeInfo ii;

if (!ii.decode(type, i))

continue;

DEBUG(log, out).print("adding itemdef type {}\n", ii.getToken());

add_value(ii.getToken());

}

return all;

FuncReadImport read_value, int32_t list_size, vector<char>& pile_list, item_type::item_type type) {

int num_elems = Items::getSubtypeCount(type);

pile_list.resize(num_elems, '\0');

if (all) {

for (auto idx = 0; idx < num_elems; ++idx) {

ItemTypeInfo ii;

ii.decode(type, idx);

set_filter_elem(out, subcat, filters, val, ii.toString(), idx, pile_list.at(idx));

}

return;

}

for (auto i = 0; i < list_size; ++i) {

string id = read_value(i);

ItemTypeInfo ii;

if (!ii.find(id))

continue;

if (ii.subtype < 0 || size_t(ii.subtype) >= pile_list.size()) {

WARN(log, out).print("item type index invalid: {}\n", ii.subtype);

continue;

}

set_filter_elem(out, subcat, filters, val, id, ii.subtype, pile_list.at(ii.subtype));

}

const bool(&quality_list)[7]) {

using df::enums::item_quality::item_quality;

using quality_traits = df::enum_traits<item_quality>;

bool all = true;

for (size_t i = 0; i < 7; ++i) {

if (!quality_list[i]) {

all = false;

continue;

}

const string f_type(quality_traits::key_table[i]);

add_value(f_type);

DEBUG(log, out).print("adding quality {}\n", f_type);

}

return all;

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(out, subcat, filters, val, id, idx, pile_list[idx]);

}

return;

}

using df::enums::item_quality::item_quality;

for (int i = 0; i < list_size; ++i) {

const string quality = read_value(i);

df::enum_traits<item_quality>::base_type idx = token_to_enum_val<item_quality>(quality);

if (idx < 0) {

WARN(log, out).print("invalid quality token: {}\n", quality);

continue;

}

set_filter_elem(out, subcat, filters, val, quality, idx, pile_list[idx]);

}

int idx) {

auto it = other_mats.find(idx);

if (it == other_mats.end())

return string();

return it->second;

const string& token) {

for (auto it = other_mats.begin(); it != other_mats.end(); ++it) {

if (it->second == token)

return it->first;

}

return -1;

const std::map<int, string> other_mats,

FuncWriteExport add_value,

vector<char> list) {

bool all = true;

for (size_t i = 0; i < list.size(); ++i) {

if (!list.at(i)) {

all = false;

continue;

}

const string token = other_mats_index(other_mats, i);

if (token.empty()) {

WARN(log, out).print("invalid other material with index {}\n", i);

continue;

}

add_value(token);

DEBUG(log, out).print("other mats {} is {}\n", i, token);

}

return all;

const std::map<int, string> other_mats, FuncReadImport read_value, int32_t list_size, vector<char>& 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(out, subcat, filters, val, entry.second, entry.first, pile_list.at(entry.first));

return;

}

for (int i = 0; i < list_size; ++i) {

const string token = read_value(i);

size_t idx = other_mats_token(other_mats, token);

if (idx < 0) {

WARN(log, out).print("invalid other mat with token {}\n", token);

continue;

}

if (idx >= num_elems) {

WARN(log, out).print("other_mats index too large! idx[{}] max_size[{}]\n", idx, num_elems);

continue;

}

set_filter_elem(out, subcat, filters, val, token, idx, pile_list.at(idx));

}

const vector<char>* list,

organic_mat_category::organic_mat_category cat) {

bool all = true;

if (!list) {

DEBUG(log, out).print("serialize_list_organic_mat: list null\n");

return all;

}

for (size_t i = 0; i < list->size(); ++i) {

if (!list->at(i)) {

all = false;

continue;

}

OrganicMatLookup::FoodMat food_mat;

OrganicMatLookup::food_mat_by_idx(out, cat, i, food_mat);

string token = OrganicMatLookup::food_token_by_idx(out, food_mat);

if (token.empty()) {

DEBUG(log, out).print("food mat invalid :(\n");

continue;

}

DEBUG(log, out).print("organic_material {} is {}\n", i, token);

add_value(token);

}

return all;

auto str = OrganicMatLookup::food_token_by_idx(out, food_mat);

if (auto plant = food_mat.material.plant) {

if (plant->flags.is_set(df::plant_raw_flags::DRINK))

str += "/brewable";

if (plant->flags.is_set(df::plant_raw_flags::MILL))

str += "/millable";

if (auto mat = food_mat.material.material) {

if (mat->flags.is_set(df::material_flags::STRUCTURAL_PLANT_MAT) &&

(plant->flags.is_set(df::plant_raw_flags::THREAD) ||

plant->flags.is_set(df::plant_raw_flags::EXTRACT_VIAL) ||

plant->flags.is_set(df::plant_raw_flags::EXTRACT_BARREL)))

str += "/processable";

}

}

return str;

FuncReadImport read_value, size_t list_size, vector<char>& 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) {

OrganicMatLookup::FoodMat food_mat;

OrganicMatLookup::food_mat_by_idx(out, cat, idx, food_mat);

set_filter_elem(out, subcat, filters, val, get_filter_string(out, food_mat), 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(out, cat, token);

if (idx < 0 || size_t(idx) >= num_elems) {

WARN(log, out).print("organic mat index too large! idx[{}] max_size[{}]\n", idx, num_elems);

continue;

}

OrganicMatLookup::FoodMat food_mat;

OrganicMatLookup::food_mat_by_idx(out, cat, idx, food_mat);

set_filter_elem(out, subcat, filters, val, get_filter_string(out, food_mat), idx, pile_list.at(idx));

}

bool all = world->raws.descriptors.colors.size() == colors->size();

if (!colors) {

DEBUG(log, out).print("serialize_list_color: list null\n");

return all;

}

for (size_t i = 0; i < colors->size(); ++i) {

if (!colors->at(i)) {

all = false;

continue;

}

add_value(world->raws.descriptors.colors[i]->id);

}

return all;

auto& colors = world->raws.descriptors.colors;

size_t num_colors = colors.size();

for (size_t idx = 0; idx < num_colors; ++ idx) {

if (colors[idx]->id == token) {

return idx;

}

}

return SIZE_MAX;

FuncReadImport read_value, int32_t list_size, vector<char>& pile_list) {

size_t num_elems = world->raws.descriptors.colors.size();

pile_list.resize(num_elems, '\0');

if (all) {

for (size_t idx = 0; idx < num_elems; ++idx) {

set_filter_elem(out, subcat, filters, val, world->raws.descriptors.colors[idx]->id, idx, pile_list[idx]);

}

return;

}

for (int32_t idx = 0; idx < list_size; ++idx) {

const string& value = read_value(idx);

size_t color = find_color_by_token(value);

if (color == SIZE_MAX) {

WARN(log, out).print("unknown color {}\n", value);

continue;

}

set_filter_elem(out, subcat, filters, val, value, color, pile_list[color]);

}

FuncWriteExport add_value, const vector<char>& list) {

using df::enums::item_type::item_type;

using type_traits = df::enum_traits<item_type>;

bool all = true;

size_t num_item_types = list.size();

DEBUG(log, out).print("item_type size = {} size limit = {} typecasted: {}\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) {

if (i < num_item_types && !list.at(i)) {

all = false;

continue;

}

const item_type type = (item_type)((df::enum_traits<item_type>::base_type)i);

string r_type(type_traits::key_table[i + 1]);

if (!is_allowed(type))

continue;

add_value(r_type);

DEBUG(log, out).print("item_type key_table[{}] type[{}] is {}\n", i + 1, (int16_t)type, r_type);

}

return all;

FuncItemAllowed is_allowed, FuncReadImport read_value, int32_t list_size, vector<char>& pile_list) {

// TODO can we remove the hardcoded list size?

size_t num_elems = 112;

pile_list.resize(num_elems, '\0');

for (size_t i = 0; i < num_elems; ++i) {

if (!is_allowed((df::item_type)i))

pile_list.at(i) = 1;

}

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(out, subcat, filters, val, id, idx, pile_list.at(idx));

}

return;

}

using df::enums::item_type::item_type;

for (int i = 0; i < list_size; ++i) {

const string token = read_value(i);

const df::enum_traits<item_type>::base_type idx = token_to_enum_val<item_type>(token);

if (!is_allowed((item_type)idx))

continue;

if (idx < 0 || size_t(idx) >= num_elems) {

WARN(log, out).print("error item_type index too large! idx[{}] max_size[{}]\n", idx, num_elems);

continue;

}

set_filter_elem(out, subcat, filters, val, token, idx, pile_list.at(idx));

}

FuncWriteExport add_value, const vector<char>& list) {

bool all = true;

MaterialInfo mi;

for (size_t i = 0; i < list.size(); ++i) {

if (!list.at(i)) {

all = false;

continue;

}

mi.decode(0, i);

if (!is_allowed(mi))

continue;

DEBUG(log, out).print("adding material {}\n", mi.getToken());

add_value(mi.getToken());

}

return all;

FuncMaterialAllowed is_allowed, FuncReadImport read_value, int32_t list_size,

vector<char>& pile_list) {

// we initialize all disallowed values to 1

// why? because that's how the memory is in DF before we muck with it.

size_t num_elems = world->raws.inorganics.all.size();

pile_list.resize(num_elems, 0);

for (size_t i = 0; i < pile_list.size(); ++i) {

MaterialInfo mi(0, i);

if (!is_allowed(mi))

pile_list.at(i) = 1;

}

if (all) {

for (size_t idx = 0; idx < num_elems; ++idx) {

MaterialInfo mi;

mi.decode(0, idx);

set_filter_elem(out, subcat, filters, val, mi.toString(), idx, pile_list.at(idx));

}

return;

}

for (auto i = 0; i < list_size; ++i) {

string id = read_value(i);

MaterialInfo mi;

if (!mi.find(id) || !is_allowed(mi))

continue;

if (mi.index < 0 || size_t(mi.index) >= pile_list.size()) {

WARN(log, out).print("material type index invalid: {}\n", mi.index);

continue;

}

set_filter_elem(out, subcat, filters, val, id, mi.index, pile_list.at(mi.index));

}

bool all = true;

for (size_t i = 0; i < list.size(); ++i) {

if (!list.at(i)) {

all = false;

continue;

}

df::creature_raw* r = find_creature(i);

if (r->flags.is_set(creature_raw_flags::GENERATED)

|| r->creature_id == "EQUIPMENT_WAGON")

continue;

DEBUG(log, out).print("adding creature {}\n", r->creature_id);

add_value(r->creature_id);

}

return all;

if (!r->caste.size() ||

(!r->caste[0]->flags.is_set(df::enums::caste_raw_flags::PET) &&

!r->caste[0]->flags.is_set(df::enums::caste_raw_flags::PET_EXOTIC)))

return r->name[0];

return r->name[0] + "/tameable";

FuncReadImport read_value, int32_t list_size, vector<char>& 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(out, subcat, filters, val, get_filter_string(r), r->creature_id, pile_list.at(idx));

}

return;

}

for (auto i = 0; i < list_size; ++i) {

string id = read_value(i);

int idx = find_creature(id);

if (idx < 0 || size_t(idx) >= num_elems) {

WARN(log, out).print("animal index invalid: {}\n", idx);

continue;

}

auto r = find_creature(idx);

set_filter_elem(out, subcat, filters, val, get_filter_string(r), r->creature_id, pile_list.at(idx));

}

enum df::stockpile_group_set::Mask cat_mask,

std::function<T_cat_set* ()> mutable_cat_fn,

std::function<bool(color_ostream&, T_cat_set*)> write_cat_fn) {

if (!(cat_flags & cat_mask))

return;

T_cat_set* cat_set = mutable_cat_fn();

if (!include_types) {

DEBUG(log, out).print("including all for {} since only category is being recorded\n", name);

cat_set->set_all(true);

return;

}

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, out).print("including all for {} since all fields were enabled\n", name);

cat_set->Clear();

cat_set->set_all(true);

}

if (includedElements & INCLUDED_ELEMENTS_GENERAL)

write_general(out);

if (!(includedElements & INCLUDED_ELEMENTS_CATEGORIES))

return;

DEBUG(log, out).print("GROUP SET {}\n",

bitfield_to_string(mSettings->flags).c_str());

bool include_types = 0 != (includedElements & INCLUDED_ELEMENTS_TYPES);

write_cat<StockpileSettings_AmmoSet>(out, "ammo", include_types,

mSettings->flags.whole,

mSettings->flags.mask_ammo,

std::bind(&StockpileSettings::mutable_ammo, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_ammo, this, _1, _2));

write_cat<StockpileSettings_AnimalsSet>(out, "animals", include_types,

mSettings->flags.whole,

mSettings->flags.mask_animals,

std::bind(&StockpileSettings::mutable_animals, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_animals, this, _1, _2));

write_cat<StockpileSettings_ArmorSet>(out, "armor", include_types,

mSettings->flags.whole,

mSettings->flags.mask_armor,

std::bind(&StockpileSettings::mutable_armor, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_armor, this, _1, _2));

write_cat<StockpileSettings_BarsBlocksSet>(out, "bars_blocks", include_types,

mSettings->flags.whole,

mSettings->flags.mask_bars_blocks,

std::bind(&StockpileSettings::mutable_barsblocks, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_bars_blocks, this, _1, _2));

write_cat<StockpileSettings_ClothSet>(out, "cloth", include_types,

mSettings->flags.whole,

mSettings->flags.mask_cloth,

std::bind(&StockpileSettings::mutable_cloth, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_cloth, this, _1, _2));

write_cat<StockpileSettings_CoinSet>(out, "coin", include_types,

mSettings->flags.whole,

mSettings->flags.mask_coins,

std::bind(&StockpileSettings::mutable_coin, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_coins, this, _1, _2));

write_cat<StockpileSettings_FinishedGoodsSet>(out, "finished_goods", include_types,

mSettings->flags.whole,

mSettings->flags.mask_finished_goods,

std::bind(&StockpileSettings::mutable_finished_goods, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_finished_goods, this, _1, _2));

write_cat<StockpileSettings_FoodSet>(out, "food", include_types,

mSettings->flags.whole,

mSettings->flags.mask_food,

std::bind(&StockpileSettings::mutable_food, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_food, this, _1, _2));

write_cat<StockpileSettings_FurnitureSet>(out, "furniture", include_types,

mSettings->flags.whole,

mSettings->flags.mask_furniture,

std::bind(&StockpileSettings::mutable_furniture, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_furniture, this, _1, _2));

write_cat<StockpileSettings_GemsSet>(out, "gems", include_types,

mSettings->flags.whole,

mSettings->flags.mask_gems,

std::bind(&StockpileSettings::mutable_gems, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_gems, this, _1, _2));

write_cat<StockpileSettings_LeatherSet>(out, "leather", include_types,

mSettings->flags.whole,

mSettings->flags.mask_leather,

std::bind(&StockpileSettings::mutable_leather, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_leather, this, _1, _2));

write_cat<StockpileSettings_CorpsesSet>(out, "corpses", include_types,

mSettings->flags.whole,

mSettings->flags.mask_corpses,

std::bind(&StockpileSettings::mutable_corpses_v50, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_corpses, this, _1, _2));

write_cat<StockpileSettings_RefuseSet>(out, "refuse", include_types,

mSettings->flags.whole,

mSettings->flags.mask_refuse,

std::bind(&StockpileSettings::mutable_refuse, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_refuse, this, _1, _2));

write_cat<StockpileSettings_SheetSet>(out, "sheet", include_types,

mSettings->flags.whole,

mSettings->flags.mask_sheet,

std::bind(&StockpileSettings::mutable_sheet, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_sheet, this, _1, _2));

write_cat<StockpileSettings_StoneSet>(out, "stone", include_types,

mSettings->flags.whole,

mSettings->flags.mask_stone,

std::bind(&StockpileSettings::mutable_stone, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_stone, this, _1, _2));

write_cat<StockpileSettings_WeaponsSet>(out, "weapons", include_types,

mSettings->flags.whole,

mSettings->flags.mask_weapons,

std::bind(&StockpileSettings::mutable_weapons, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_weapons, this, _1, _2));

write_cat<StockpileSettings_WoodSet>(out, "wood", include_types,

mSettings->flags.whole,

mSettings->flags.mask_wood,

std::bind(&StockpileSettings::mutable_wood, &mBuffer),

std::bind(&StockpileSettingsSerializer::write_wood, this, _1, _2));

if (includedElements & INCLUDED_ELEMENTS_CONTAINERS)

write_containers(out);

StockpileSettingsSerializer::write(out, includedElements);

DEBUG(log).print("==READ==\n");

read_general(out, mode);

read_ammo(out, mode, filters);

read_animals(out, mode, filters);

read_armor(out, mode, filters);

read_bars_blocks(out, mode, filters);

read_cloth(out, mode, filters);

read_coins(out, mode, filters);

read_finished_goods(out, mode, filters);

read_food(out, mode, filters);

read_furniture(out, mode, filters);

read_gems(out, mode, filters);

read_leather(out, mode, filters);

// support for old versions before corpses had a set

if (mBuffer.has_corpses()) {

StockpileSettings::CorpsesSet* corpses = mBuffer.mutable_corpses_v50();

corpses->set_all(true);

}

read_corpses(out, 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);

DEBUG(log, out).print("writing container settings\n");

mBuffer.set_max_bins(mPile->storage.max_bins);

mBuffer.set_max_barrels(mPile->storage.max_barrels);

mBuffer.set_max_wheelbarrows(mPile->storage.max_wheelbarrows);

std::function<bool()> has_elem_fn,

std::function<T_elem_ret()> elem_fn,

T_elem &setting) {

if (!has_elem_fn())

return;

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, out).print("setting {} to {}\n", name, val);

setting = val;

}

std::function<bool()> has_cat_fn,

std::function<const T_cat &()> cat_fn,

uint32_t & cat_flags,

enum df::stockpile_group_set::Mask cat_mask,

std::function<void()> clear_fn,

std::function<void(bool, char)> set_fn) {

if (mode == DESERIALIZE_MODE_SET) {

DEBUG(log, out).print("clearing {}\n", name);

cat_flags &= ~cat_mask;

clear_fn();

}

if (!has_cat_fn())

return;

if (mode == DESERIALIZE_MODE_DISABLE && !(cat_flags & cat_mask))

return;

if (mode == DESERIALIZE_MODE_SET || mode == DESERIALIZE_MODE_ENABLE)

cat_flags |= cat_mask;

bool all = cat_fn().all();

char val = (mode == DESERIALIZE_MODE_DISABLE) ? (char)0 : (char)1;

DEBUG(log, out).print("setting {} {} elements to {}\n",

all ? "all" : "marked", name, val);

set_fn(all, val);

read_elem<int16_t, int32_t>(out, "max_bins", mode,

std::bind(&StockpileSettings::has_max_bins, mBuffer),

std::bind(&StockpileSettings::max_bins, mBuffer),

mPile->storage.max_bins);

read_elem<int16_t, int32_t>(out, "max_barrels", mode,

std::bind(&StockpileSettings::has_max_barrels, mBuffer),

std::bind(&StockpileSettings::max_barrels, mBuffer),

mPile->storage.max_barrels);

read_elem<int16_t, int32_t>(out, "max_wheelbarrows", mode,

std::bind(&StockpileSettings::has_max_wheelbarrows, mBuffer),

std::bind(&StockpileSettings::max_wheelbarrows, mBuffer),

mPile->storage.max_wheelbarrows);

DEBUG(log, out).print("writing general settings\n");

mBuffer.set_allow_inorganic(mSettings->misc.allow_inorganic);

mBuffer.set_allow_organic(mSettings->misc.allow_organic);

read_elem<bool, bool>(out, "allow_inorganic", mode,

std::bind(&StockpileSettings::has_allow_inorganic, mBuffer),

std::bind(&StockpileSettings::allow_inorganic, mBuffer),

mSettings->misc.allow_inorganic);

read_elem<bool, bool>(out, "allow_organic", mode,

std::bind(&StockpileSettings::has_allow_organic, mBuffer),

std::bind(&StockpileSettings::allow_organic, mBuffer),

mSettings->misc.allow_organic);

StockpileSettingsSerializer::read_general(out, mode);

if (!mBuffer.has_use_links_only())

return;

bool use_links_only = mBuffer.use_links_only();

DEBUG(log, out).print("setting use_links_only to {}\n", use_links_only);

mPile->stockpile_flag.bits.use_links_only = use_links_only;

bool all = serialize_list_itemdef(out,

[&](const string& token) { ammo->add_type(token); },

mSettings->ammo.type,

vector<df::itemdef*>(world->raws.itemdefs.ammo.begin(), world->raws.itemdefs.ammo.end()),

item_type::AMMO);

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, out).print("ammo other materials > 2: {}\n",

mSettings->ammo.other_mats.size());

}

size_t num_other_mats = std::min(size_t(2),

mSettings->ammo.other_mats.size());

for (size_t i = 0; i < num_other_mats; ++i) {