refactor: publish parser routing snapshots

Author: Toilettrauma

CMakeLists.txt

@@ -79,6 +79,7 @@ endif()
 find_package(lexbor REQUIRED)
 find_package(fmt REQUIRED)
 find_package(Boost REQUIRED COMPONENTS json regex)
+find_package(tl-expected CONFIG REQUIRED)
 
 # ---- ADD LIBRARY
 
@@ -88,6 +89,7 @@ add_library(aniparse ${aniparse_library_type}
 	"include/aniparse/detail/BitsetLite.hpp"
 	"include/aniparse/detail/StrongBitset.hpp"
 	"include/aniparse/detail/DomainScanner.hpp"
+	"include/aniparse/detail/DomainStore.hpp"
 	# src/net/Client.cpp (the curl backend) is added conditionally below.
 	"include/aniparse/net/Client.hpp"
 	"include/aniparse/net/CancellingTask.hpp"
@@ -209,14 +211,15 @@ target_include_directories(aniparse PUBLIC
 	$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-# fmt / Boost are find_package'd imported targets a consumer recreates via
+# fmt / Boost / tl-expected are find_package'd imported targets a consumer recreates via
 # find_dependency (see aniparse-config.cmake.in), so they belong on the install
 # interface too — not only BUILD_INTERFACE. lexbor is a vendored static lib the
 # install does not ship, so it stays build-only.
 target_link_libraries(aniparse PUBLIC
 	fmt::fmt
 	Boost::json
 	Boost::regex
+	tl::expected
 	$<BUILD_INTERFACE:${LEXBOR_LIBRARIES}>
 )
 
@@ -322,4 +325,4 @@ install(FILES
 	"${CMAKE_CURRENT_BINARY_DIR}/aniparse-config.cmake"
 	"${CMAKE_CURRENT_BINARY_DIR}/aniparse-config-version.cmake"
 	DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/aniparse"
-)
+)

aniparse-config.cmake.in

@@ -11,6 +11,7 @@ include(CMakeFindDependencyMacro)
 # consumer's project.
 find_dependency(fmt CONFIG)
 find_dependency(Boost CONFIG COMPONENTS json regex)
+find_dependency(tl-expected CONFIG)
 
 include("${CMAKE_CURRENT_LIST_DIR}/aniparse-targets.cmake")
 

include/aniparse/ParserStore.hpp

@@ -4,14 +4,12 @@
  * Author: Toilettrauma <macosinternal@gmail.com>
  */
 #pragma once
-#include "aniparse/detail/DomainScanner.hpp"
+#include "aniparse/detail/DomainStore.hpp"
 #include "aniparse/Parser.hpp"
 #include "aniparse/types/ParsedUrl.hpp"
 
-#include "aniparse/utility/AtomicSharedPtr.hpp"
 #include <string>
 #include <map>
-#include <numeric>
 #include <optional>
 #include <vector>
 
@@ -32,7 +30,36 @@ struct UrlRoute {
  */
 class ParserStore {
 public:
-	ParserStore();
+	struct ParserDomainEmitter {
+		void operator()(const Parser& parser, EmplaceDomainsContext& context) const {
+			parser.emplace_domains(context);
+		}
+	};
+	using Domains = detail::DomainStore<Parser, EmplaceDomainsContext, ParserDomainEmitter>;
+	using DomainEdit = Domains::Edit;
+
+	class Edit {
+	public:
+		Edit(const Edit&) = delete;
+		Edit& operator=(const Edit&) = delete;
+		Edit(Edit&&) noexcept = default;
+		Edit& operator=(Edit&&) noexcept = default;
+
+		std::shared_ptr<Parser> add_parser(std::shared_ptr<Parser> parser);
+		bool remove_parser(std::string_view identifier);
+		void refresh_domains(std::map<std::string, std::vector<std::string>, std::less<>> volatile_domains);
+		void commit();
+
+	private:
+		friend class ParserStore;
+		explicit Edit(DomainEdit edit) : edit_(std::move(edit)) {}
+		DomainEdit edit_;
+	};
+
+	ParserStore() = default;
+
+	/// Start a local mutable draft; commit() publishes one new routing snapshot.
+	[[nodiscard]] Edit begin_edit() { return Edit(domains_.begin_edit()); }
 
 	/**
 	 * @brief Add parser to the store
@@ -100,28 +127,6 @@ class ParserStore {
 	void refresh_domains(std::map<std::string, std::vector<std::string>, std::less<>> volatile_domains);
 
 private:
-	using Scanner = DomainScanner<std::shared_ptr<Parser>>;
-
-	/**
-	 * Check if the parser identifier doesn't conflicting with existing parsers
-	 * @see Parser
-	 * @param parser The parser to check identifier uniqueness
-	 * @return true if the identifier is unique, false otherwise
-	 */
-	bool check_is_conflicting(const std::shared_ptr<Parser>& parser) const;
-
-	/**
-	 * Build a fresh routing index from the current parsers and volatile domains.
-	 * Every parser contributes its static domains plus any volatile domains keyed
-	 * by its identifier. Pure: produces a new scanner and mutates nothing.
-	 */
-	std::shared_ptr<Scanner> build_scanner() const;
-
-	/// Rebuild the routing index and swap it in atomically.
-	void rebuild_index();
-
-	std::map<std::string, std::shared_ptr<Parser>, std::less<>> parsers_;
-	std::map<std::string, std::vector<std::string>, std::less<>> volatile_domains_;
-	AtomicSharedPtr<Scanner> scanner_;
+	Domains domains_;
 };
-} // namespace aniparse
+} // namespace aniparse

include/aniparse/detail/DomainStore.hpp

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2025-2026 Toilettrauma
+ *
+ * Author: Toilettrauma <macosinternal@gmail.com>
+ */
+#pragma once
+#include "aniparse/detail/DomainScanner.hpp"
+#include "aniparse/utility/AtomicSharedPtr.hpp"
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <ranges>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace aniparse::detail {
+
+/**
+ * @brief Immutable-snapshot domain registry for parser-like source stores.
+ *
+ * Readers load one complete snapshot. Writers make an Edit, mutate only its
+ * local maps, then commit one newly built DomainScanner with an atomic swap.
+ * A stale concurrent edit is rejected rather than silently overwriting a newer
+ * registry revision.
+ */
+template <class T, class DomainContext, class DomainEmitter>
+class DomainStore {
+public:
+	using ValuePtr = std::shared_ptr<T>;
+	using DomainOverrides = std::map<std::string, std::vector<std::string>, std::less<>>;
+
+	class Edit;
+
+	DomainStore()
+	    : snapshot_(make_snapshot({}, {})) {}
+
+	[[nodiscard]] Edit begin_edit();
+
+	[[nodiscard]] bool contains(std::string_view identifier) const {
+		return snapshot_.load()->entries.contains(identifier);
+	}
+
+	[[nodiscard]] ValuePtr find_by_key(std::string_view identifier) const {
+		auto snapshot = snapshot_.load();
+		auto it       = snapshot->entries.find(identifier);
+		return it == snapshot->entries.end() ? nullptr : it->second.value;
+	}
+
+	[[nodiscard]] std::vector<ValuePtr> values() const {
+		auto snapshot = snapshot_.load();
+		std::vector<ValuePtr> result;
+		result.reserve(snapshot->entries.size());
+		for (const auto& [identifier, entry] : snapshot->entries) {
+			result.push_back(entry.value);
+		}
+		return result;
+	}
+
+	template <class Predicate>
+	[[nodiscard]] ValuePtr find_by_host(std::string_view host, Predicate&& accepts) const {
+		auto snapshot = snapshot_.load();
+		auto labels   = split_domains(host);
+		auto found    = snapshot->scanner->search_all(labels, [&accepts](ValuePtr& value) {
+			return accepts(*value);
+		});
+		return found ? *found : nullptr;
+	}
+
+private:
+	using Scanner = DomainScanner<ValuePtr>;
+
+	struct Entry {
+		ValuePtr value;
+	};
+
+	class DomainAdder final : public DomainContext {
+	public:
+		DomainAdder(Scanner& scanner, ValuePtr value)
+		    : scanner_(scanner), value_(std::move(value)) {}
+
+		void add_domain(std::string_view domain) override {
+			scanner_.add_domain_parser(split_domains(domain), value_);
+		}
+
+	private:
+		Scanner& scanner_;
+		ValuePtr value_;
+	};
+
+	struct Snapshot {
+		std::map<std::string, Entry, std::less<>> entries;
+		DomainOverrides volatile_domains;
+		std::shared_ptr<Scanner> scanner;
+	};
+
+	template <std::ranges::viewable_range Range>
+	static constexpr auto split_domains(Range&& range) {
+		// clang-format off
+		return std::forward<Range>(range)
+		       | std::views::reverse
+		       | std::views::split('.')
+		       | std::views::transform(std::views::reverse);
+		// clang-format on
+	}
+
+	std::shared_ptr<const Snapshot> make_snapshot(
+	    std::map<std::string, Entry, std::less<>> entries,
+	    DomainOverrides volatile_domains) {
+		auto scanner = std::make_shared<Scanner>();
+		for (const auto& [identifier, entry] : entries) {
+			DomainAdder adder(*scanner, entry.value);
+			emitter_(*entry.value, adder);
+			auto add_domains = [&scanner, &entry](const std::vector<std::string>& domains) {
+				for (const std::string& domain : domains) {
+					scanner->add_domain_parser(split_domains(domain), entry.value);
+				}
+			};
+			if (auto it = volatile_domains.find(identifier); it != volatile_domains.end()) {
+				add_domains(it->second);
+			}
+		}
+		return std::make_shared<const Snapshot>(Snapshot{
+		    .entries = std::move(entries),
+		    .volatile_domains = std::move(volatile_domains),
+		    .scanner = std::move(scanner),
+		});
+	}
+
+	void commit(std::shared_ptr<const Snapshot> base,
+	            std::map<std::string, Entry, std::less<>> entries,
+	            DomainOverrides volatile_domains) {
+		std::lock_guard lock(writer_mutex_);
+		auto live = snapshot_.load();
+		if (live != base) {
+			throw std::logic_error("DomainStore edit is stale");
+		}
+		snapshot_.store(make_snapshot(std::move(entries), std::move(volatile_domains)));
+	}
+
+	mutable std::mutex writer_mutex_;
+	DomainEmitter emitter_;
+	AtomicSharedPtr<const Snapshot> snapshot_;
+
+public:
+	/** A local mutable draft of one DomainStore snapshot. */
+	class Edit {
+	public:
+		Edit(const Edit&) = delete;
+		Edit& operator=(const Edit&) = delete;
+		Edit(Edit&&) noexcept = default;
+		Edit& operator=(Edit&&) noexcept = default;
+
+		ValuePtr add(std::string identifier, ValuePtr value) {
+			auto [it, inserted] = entries_.emplace(
+			    std::move(identifier), Entry{ .value = std::move(value) });
+			return inserted ? it->second.value : nullptr;
+		}
+
+		[[nodiscard]] bool contains(std::string_view identifier) const {
+			return entries_.contains(identifier);
+		}
+
+		bool remove(std::string_view identifier) {
+			auto it = entries_.find(identifier);
+			if (it == entries_.end()) {
+				return false;
+			}
+			entries_.erase(it);
+			return true;
+		}
+
+		void set_volatile_domains(DomainOverrides volatile_domains) {
+			volatile_domains_ = std::move(volatile_domains);
+		}
+
+		void commit() {
+			if (!store_) {
+				throw std::logic_error("DomainStore edit was already committed");
+			}
+			store_->commit(base_, std::move(entries_), std::move(volatile_domains_));
+			store_ = nullptr;
+		}
+
+	private:
+		friend class DomainStore;
+
+		explicit Edit(DomainStore& store)
+		    : store_(&store), base_(store.snapshot_.load())
+		    , entries_(base_->entries), volatile_domains_(base_->volatile_domains) {}
+
+		DomainStore* store_;
+		std::shared_ptr<const Snapshot> base_;
+		std::map<std::string, Entry, std::less<>> entries_;
+		DomainOverrides volatile_domains_;
+	};
+
+};
+
+template <class T, class DomainContext, class DomainEmitter>
+typename DomainStore<T, DomainContext, DomainEmitter>::Edit
+DomainStore<T, DomainContext, DomainEmitter>::begin_edit() {
+	return Edit(*this);
+}
+
+} // namespace aniparse::detail