284 lines
9.2 KiB
C++
284 lines
9.2 KiB
C++
#pragma once
|
|
|
|
#include "modules/Materials.h"
|
|
|
|
#include "df/itemdef.h"
|
|
#include "df/organic_mat_category.h"
|
|
|
|
#include "proto/stockpiles.pb.h"
|
|
|
|
#include <functional>
|
|
|
|
namespace df
|
|
{
|
|
struct building_stockpilest;
|
|
}
|
|
|
|
/**
|
|
* Class for serializing the stockpile_settings structure into a Google protobuf
|
|
*/
|
|
class StockpileSerializer {
|
|
public:
|
|
/**
|
|
* @param out for debugging
|
|
* @param stockpile stockpile to read or write settings to
|
|
*/
|
|
|
|
StockpileSerializer(df::building_stockpilest* stockpile);
|
|
|
|
~StockpileSerializer();
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Will serialize stockpile settings to a file (overwrites existing files)
|
|
* @return success/failure
|
|
*/
|
|
bool serialize_to_file(const std::string& file);
|
|
|
|
/**
|
|
* Again, copied from message.cc
|
|
*/
|
|
bool parse_from_istream(std::istream* input);
|
|
|
|
/**
|
|
* Read stockpile settings from file
|
|
*/
|
|
bool unserialize_from_file(const std::string& file);
|
|
|
|
private:
|
|
df::building_stockpilest* mPile;
|
|
dfstockpiles::StockpileSettings mBuffer;
|
|
std::map<int, std::string> mOtherMatsFurniture;
|
|
std::map<int, std::string> mOtherMatsFinishedGoods;
|
|
std::map<int, std::string> mOtherMatsBars;
|
|
std::map<int, std::string> mOtherMatsBlocks;
|
|
std::map<int, std::string> mOtherMatsWeaponsArmor;
|
|
|
|
/**
|
|
read memory structures and serialize to protobuf
|
|
*/
|
|
void write();
|
|
|
|
// parse serialized data into ui indices
|
|
void read();
|
|
|
|
/**
|
|
* Find an enum's value based off the string label.
|
|
* @param traits the enum's trait struct
|
|
* @param token the string value in key_table
|
|
* @return the enum's value, -1 if not found
|
|
*/
|
|
template <typename E>
|
|
static typename df::enum_traits<E>::base_type linear_index(df::enum_traits<E> traits, const std::string& token) {
|
|
auto j = traits.first_item_value;
|
|
auto limit = traits.last_item_value;
|
|
// sometimes enums start at -1, which is bad news for array indexing
|
|
if (j < 0) {
|
|
j += abs(traits.first_item_value);
|
|
limit += abs(traits.first_item_value);
|
|
}
|
|
for (; j <= limit; ++j) {
|
|
if (token.compare(traits.key_table[j]) == 0)
|
|
return j;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// read the token from the serailized list during import
|
|
typedef std::function<std::string(const size_t&)> FuncReadImport;
|
|
// add the token to the serialized list during export
|
|
typedef std::function<void(const std::string&)> FuncWriteExport;
|
|
// are item's of item_type allowed?
|
|
typedef std::function<bool(df::enums::item_type::item_type)> FuncItemAllowed;
|
|
// is this material allowed?
|
|
typedef std::function<bool(const DFHack::MaterialInfo&)> FuncMaterialAllowed;
|
|
|
|
// convenient struct for parsing food stockpile items
|
|
struct food_pair {
|
|
// exporting
|
|
FuncWriteExport set_value;
|
|
std::vector<char>* stockpile_values;
|
|
// importing
|
|
FuncReadImport get_value;
|
|
size_t serialized_count;
|
|
bool valid;
|
|
|
|
food_pair(FuncWriteExport s, std::vector<char>* sp_v, FuncReadImport g, size_t count)
|
|
: set_value(s), stockpile_values(sp_v), get_value(g), serialized_count(count), valid(true) { }
|
|
food_pair(): valid(false) { }
|
|
};
|
|
|
|
/**
|
|
* There are many repeated (un)serialization cases throughout the stockpile_settings structure,
|
|
* so the most common cases have been generalized into generic functions using lambdas.
|
|
*
|
|
* The basic process to serialize a stockpile_settings structure is:
|
|
* 1. loop through the list
|
|
* 2. for every element that is TRUE:
|
|
* 3. map the specific stockpile_settings index into a general material, creature, etc index
|
|
* 4. verify that type is allowed in the list (e.g., no stone in gems stockpiles)
|
|
* 5. add it to the protobuf using FuncWriteExport
|
|
*
|
|
* The unserialization process is the same in reverse.
|
|
*/
|
|
void serialize_list_organic_mat(FuncWriteExport add_value, const std::vector<char>* list, df::enums::organic_mat_category::organic_mat_category cat);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void unserialize_list_organic_mat(FuncReadImport get_value, size_t list_size, std::vector<char>* pile_list, df::enums::organic_mat_category::organic_mat_category cat);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void serialize_list_item_type(FuncItemAllowed is_allowed, FuncWriteExport add_value, const std::vector<char>& list);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void unserialize_list_item_type(FuncItemAllowed is_allowed, FuncReadImport read_value, int32_t list_size, std::vector<char>* pile_list);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void serialize_list_material(FuncMaterialAllowed is_allowed, FuncWriteExport add_value, const std::vector<char>& list);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void unserialize_list_material(FuncMaterialAllowed is_allowed, FuncReadImport read_value, int32_t list_size, std::vector<char>* pile_list);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void serialize_list_quality(FuncWriteExport add_value, const bool(&quality_list)[7]);
|
|
|
|
/**
|
|
* Set all values in a bool[7] to false
|
|
*/
|
|
void quality_clear(bool(&pile_list)[7]);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void unserialize_list_quality(FuncReadImport read_value, int32_t list_size, bool(&pile_list)[7]);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void serialize_list_other_mats(const std::map<int, std::string> other_mats, FuncWriteExport add_value, std::vector<char> list);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void unserialize_list_other_mats(const std::map<int, std::string> other_mats, FuncReadImport read_value, int32_t list_size, std::vector<char>* pile_list);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void serialize_list_itemdef(FuncWriteExport add_value, std::vector<char> list, std::vector<df::itemdef*> items, df::enums::item_type::item_type type);
|
|
|
|
/**
|
|
* @see serialize_list_organic_mat
|
|
*/
|
|
void unserialize_list_itemdef(FuncReadImport read_value, int32_t list_size, std::vector<char>* pile_list, df::enums::item_type::item_type type);
|
|
|
|
/**
|
|
* Given a list of other_materials and an index, return its corresponding token
|
|
* @return empty string if not found
|
|
* @see other_mats_token
|
|
*/
|
|
std::string other_mats_index(const std::map<int, std::string> other_mats, int idx);
|
|
|
|
/**
|
|
* Given a list of other_materials and a token, return its corresponding index
|
|
* @return -1 if not found
|
|
* @see other_mats_index
|
|
*/
|
|
int other_mats_token(const std::map<int, std::string> other_mats, const std::string& token);
|
|
|
|
void write_general();
|
|
void read_general();
|
|
|
|
void write_animals();
|
|
void read_animals();
|
|
|
|
food_pair food_map(df::enums::organic_mat_category::organic_mat_category cat);
|
|
|
|
void write_food();
|
|
void read_food();
|
|
|
|
void furniture_setup_other_mats();
|
|
void write_furniture();
|
|
bool furniture_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
void read_furniture();
|
|
|
|
bool refuse_creature_is_allowed(const df::creature_raw* raw);
|
|
|
|
void refuse_write_helper(std::function<void(const std::string&)> add_value, const std::vector<char>& list);
|
|
|
|
bool refuse_type_is_allowed(df::enums::item_type::item_type type);
|
|
|
|
void write_refuse();
|
|
void refuse_read_helper(std::function<std::string(const size_t&)> get_value, size_t list_size, std::vector<char>* pile_list);
|
|
|
|
void read_refuse();
|
|
|
|
bool stone_is_allowed(const DFHack::MaterialInfo& mi);
|
|
|
|
void write_stone();
|
|
|
|
void read_stone();
|
|
|
|
bool ammo_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
|
|
void write_ammo();
|
|
void read_ammo();
|
|
bool coins_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
|
|
void write_coins();
|
|
|
|
void read_coins();
|
|
|
|
void bars_blocks_setup_other_mats();
|
|
|
|
bool bars_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
|
|
bool blocks_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
|
|
void write_bars_blocks();
|
|
void read_bars_blocks();
|
|
bool gem_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
bool gem_cut_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
bool gem_other_mat_is_allowed(DFHack::MaterialInfo& mi);
|
|
|
|
void write_gems();
|
|
|
|
void read_gems();
|
|
|
|
bool finished_goods_type_is_allowed(df::enums::item_type::item_type type);
|
|
void finished_goods_setup_other_mats();
|
|
bool finished_goods_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
void write_finished_goods();
|
|
void read_finished_goods();
|
|
void write_leather();
|
|
void read_leather();
|
|
void write_cloth();
|
|
void read_cloth();
|
|
bool wood_mat_is_allowed(const df::plant_raw* plant);
|
|
void write_wood();
|
|
void read_wood();
|
|
bool weapons_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
void write_weapons();
|
|
void read_weapons();
|
|
void weapons_armor_setup_other_mats();
|
|
bool armor_mat_is_allowed(const DFHack::MaterialInfo& mi);
|
|
void write_armor();
|
|
void read_armor();
|
|
};
|