Method write_non_streaming_

src/serializers/RocksDbSerializer.cpp:290–367

void RocksDbSerializer::write_non_streaming_() {
	// Build a map of instances and their references/dependencies
	std::map<uint32_t, std::set<uint32_t>> dependencies, dependencies_inv;
	std::visit([&dependencies](const auto& m) {
		if constexpr (std::is_same_v<std::decay_t<decltype(m)>, IfcParse::impl::in_memory_file_storage>) {
			for (const auto& ps : m.byref_excl_) {
				for (const auto& p : ps.second) {
					dependencies[p].insert(std::get<0>(ps.first));
				}
			}
		}
	}, std::get<IfcParse::IfcFile*>(file_)->storage_);
	// Add bottom-rank nodes, inv mapping does not contain them
	for (const auto& p : *std::get<IfcParse::IfcFile*>(file_)) {
		dependencies[p.first];
	}

	for (auto& ps : dependencies) {
		for (auto& p : ps.second) {
			dependencies_inv[p].insert(ps.first);
		}
	}

	// Do a topological sort over the nodes
	std::vector<uint32_t> deps_topo_order;
	while (dependencies.size() > 0) {
		std::vector<uint32_t> no_deps;
		for (auto& ps : dependencies) {
			if (ps.second.size() == 0) {
				no_deps.push_back(ps.first);
			}
		}

		if (no_deps.size() == 0) {
			throw std::runtime_error("cyclic dependencies in model, unable to serialize");
		}

		for (auto& i : no_deps) {
			deps_topo_order.push_back(i);
		}

		// mutate mapping
		for (auto& i : no_deps) {
			dependencies.erase(i);
		}
		for (auto& i : no_deps) {
			for (auto& j : dependencies_inv[i]) {
				auto it = dependencies.find(j);
				if (it != dependencies.end()) {
					it->second.erase(i);
				}
			}
		}
	}

	// Add them in topological order, so that add() never recurses into something not previously visited
	for (auto& i : deps_topo_order) {
		output_file_->addEntity(std::get<IfcParse::IfcFile*>(file_)->instance_by_id(i), i);