min_quality = df::item_quality::Ordinary;

max_quality = default_max_quality;

decorated_only = false;

mat_mask.whole = 0;

materials.clear();

return min_quality == df::item_quality::Ordinary

&& max_quality == default_max_quality

&& !decorated_only

&& !mat_mask.whole

&& materials.empty();

if (ser.empty())

return true;

if (!parseJobMaterialCategory(&mat_mask, ser)) {

DEBUG(control).print("invalid job material category serialization: '{}'", ser);

return false;

}

return true;

if (ser.empty())

return true;

vector<string> mat_names;

split_string(&mat_names, ser, ",");

for (auto m = mat_names.begin(); m != mat_names.end(); m++) {

DFHack::MaterialInfo material;

if (!material.find(*m) || !material.isValid()) {

DEBUG(control).print("invalid material name serialization: '{}'", ser);

return false;

}

materials.emplace(material);

}

return true;

vector<string> tokens;

split_string(&tokens, serialized, "/");

if (tokens.size() < 5) {

DEBUG(control,out).print("invalid ItemFilter serialization: '{}'", serialized);

return;

}

if (!deserializeMaterialMask(tokens[0], mat_mask) || !deserializeMaterials(tokens[1], materials))

return;

setMinQuality(atoi(tokens[2].c_str()));

setMaxQuality(atoi(tokens[3].c_str()));

decorated_only = static_cast<bool>(atoi(tokens[4].c_str()));

if (tokens.size() >= 6)

default_max_quality = static_cast<df::item_quality>(atoi(tokens[5].c_str()));

std::ostringstream ser;

ser << bitfield_to_string(mat_mask, ",") << "/";

vector<string> matstrs;

for (auto &mat : materials)

matstrs.emplace_back(mat.getToken());

ser << join_strings(",", matstrs);

ser << "/" << static_cast<int>(min_quality);

ser << "/" << static_cast<int>(max_quality);

ser << "/" << static_cast<int>(decorated_only);

ser << "/" << static_cast<int>(default_max_quality);

return ser.str();

if (*quality > df::item_quality::Artifact) {

DEBUG(control).print("clamping quality to Artifact");

*quality = df::item_quality::Artifact;

}

if (*quality < df::item_quality::Ordinary) {

DEBUG(control).print("clamping quality to Ordinary");

*quality = df::item_quality::Ordinary;

}

min_quality = static_cast<df::item_quality>(quality);

clampItemQuality(&min_quality);

if (max_quality < min_quality)

max_quality = min_quality;

max_quality = static_cast<df::item_quality>(quality);

clampItemQuality(&max_quality);

if (max_quality < min_quality)

min_quality = max_quality;

if (is_default)

default_max_quality = max_quality;

for (auto &mat : materials)

if (material.matches(mat))

return true;

return false;

int16_t quality = (item->flags.bits.artifact ? df::item_quality::Artifact : item->getQuality());

if (quality < min_quality || quality > max_quality) {

TRACE(cycle).print("item outside of quality range ({} not between {} and {})\n",

ENUM_AS_STR(static_cast<df::item_quality>(quality)), ENUM_AS_STR(min_quality), ENUM_AS_STR(max_quality));

return false;

}

if (decorated_only && !item->hasImprovements()) {

TRACE(cycle).print("item needs improvements and doesn't have any\n");

return false;

}

if (!mat_mask.whole)

return true;

auto imattype = item->getActualMaterial();

auto imatindex = item->getActualMaterialIndex();

auto item_mat = DFHack::MaterialInfo(imattype, imatindex);

return (materials.size() == 0) ? matchesMask(item_mat, mat_mask) : matches(item_mat);

vector<ItemFilter> filters;

vector<string> filter_strs;

split_string(&filter_strs, serialized, ";");

for (auto &str : filter_strs) {

filters.emplace_back(out, str);

}

return filters;

vector<string> strs;

for (auto &filter : filters) {

strs.emplace_back(filter.serialize());

}

return join_strings(";", strs);