void deserializer::add_legacy_recipe()

in src/native/diffs/serialization/legacy/deserializer.cpp [87:171]

• 77 lines of code
• 12 McCabe index (conditional complexity)

void deserializer::add_legacy_recipe(
	legacy_recipe_type type,
	const diffs::core::item_definition &result_item_definition,
	std::vector<uint64_t> &number_ingredients,
	std::vector<diffs::core::item_definition> &item_ingredients)
{
	if (m_recipe_type_to_template.count(type) > 0)
	{
		auto &recipe_template = m_recipe_type_to_template[type];
		auto recipe = recipe_template->create_recipe(result_item_definition, number_ingredients, item_ingredients);

		m_all_recipes.push_back(recipe);
		return;
	}

	switch (type)
	{
	case legacy_recipe_type::region: {
		if (number_ingredients.size() != 2)
		{
			throw std::exception();
		}
		auto offset                   = number_ingredients[0];
		auto slice_number_ingredients = std::vector<uint64_t>{{offset}};
		auto slice =
			std::make_shared<basic::slice_recipe>(result_item_definition, slice_number_ingredients, item_ingredients);
		m_all_recipes.emplace_back(slice);
	}
	break;
	case legacy_recipe_type::copy:
		// nothing to do!
		break;
	case legacy_recipe_type::nested: {
		m_pending_nested_diffs.push_back(
			pending_nested_diff{result_item_definition, number_ingredients, item_ingredients});
		break;
	}

	case legacy_recipe_type::remainder: {
		m_pending_remainder_slices.emplace_back(
			pending_slice{result_item_definition, m_all_recipes.size(), number_ingredients});
		m_all_recipes.push_back(std::shared_ptr<diffs::core::recipe>());
		break;
	}
	case legacy_recipe_type::inline_asset:
		m_pending_inline_assets_slices.emplace_back(
			pending_slice{result_item_definition, m_all_recipes.size(), number_ingredients});
		m_all_recipes.push_back(std::shared_ptr<diffs::core::recipe>());
		break;

	case legacy_recipe_type::inline_asset_copy:
		m_pending_inline_assets_slice_copies.emplace_back(
			pending_slice{result_item_definition, m_all_recipes.size(), number_ingredients});
		m_all_recipes.push_back(std::shared_ptr<diffs::core::recipe>());
		break;

	case legacy_recipe_type::copy_source:
		if (m_source_item.size() == 0)
		{
			throw std::exception();
		}
		else
		{
			auto offset                   = number_ingredients[0];
			auto slice_number_ingredients = std::vector<uint64_t>{{offset}};
			auto slice_item_ingredients   = std::vector<diffs::core::item_definition>{{m_source_item}};
			auto recipe                   = std::make_shared<basic::slice_recipe>(
                result_item_definition, slice_number_ingredients, slice_item_ingredients);
			m_all_recipes.push_back(recipe);
		}
		break;
	case legacy_recipe_type::gz_decompression: {
		const uint64_t c_zlib_gz_init      = 1;
		auto decompress_number_ingredients = std::vector<uint64_t>{static_cast<uint64_t>(c_zlib_gz_init)};
		auto recipe                        = std::make_shared<compressed::zlib_decompression_recipe>(
            result_item_definition, decompress_number_ingredients, item_ingredients);
		m_all_recipes.push_back(recipe);
	}
	break;

	default:
		// Unknown recipe type!
		throw std::exception();
	}
}