The retention claim covered methods named like removal and nothing else,
so the archive forgot everything on assignment: archive = LineageArchive{}
discarded every record, and assigning a copy taken before a death
restored that organism's living state, defeating terminal death as well.
The copy and move policy is now part of the interface rather than left to
the defaults. Both forms of assignment are deleted, which also makes the
archive unswappable since swapping needs them. Declaring the copy
constructor suppresses the implicit moves, so a move decays to a copy and
a moved-from archive still holds every record rather than being emptied
the way a moved-from container would be.
Copying stays available on purpose: a clone takes nothing from the
original, and GENOME_MODEL expects migrations to be rehearsed on cloned
worlds. Deleting the move constructor as well would be stricter but would
stop an archive being returned from a function, so it decays instead.
The interface tests now cover assignment, replacement from a temporary
and swapping alongside the named methods, each with a std::vector
positive control so the checks are known to be live. Runtime checks
confirm a copy taken before a death leaves the original's terminal record
standing, and that a moved-from archive still holds everything. All four
static assertions were confirmed to fail with the deletions removed.
ADR-0034 said the type offered no way to forget. That was too narrow, and
the Decision and Alternatives now say why assignment counts.
Native Release, clang-tidy analysis, ASan and format checks pass 21/21.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
95 lines
4.4 KiB
C++
95 lines
4.4 KiB
C++
#pragma once
|
|
|
|
#include "evo/biology/genome.hpp"
|
|
#include "evo/core/types.hpp"
|
|
|
|
namespace evo::biology {
|
|
// What the archive can establish about itself. There is deliberately no third
|
|
// value: terminal extinction is a policy judgement over a reconciled world
|
|
// watermark covering suspended members, eggs, spores and in-flight transfers,
|
|
// none of which this type can see. Absence is not extinction.
|
|
enum class LineageStatus : std::uint8_t { living, absent };
|
|
struct OrganismRecord {
|
|
std::uint64_t genome;
|
|
Tick born;
|
|
Tick died; // meaningful only once alive is false
|
|
bool alive; // death is terminal; this never returns to true
|
|
auto operator<=>(const OrganismRecord&) const = default;
|
|
};
|
|
enum class HistoryError : std::uint8_t {
|
|
duplicate_genome,
|
|
unknown_genome,
|
|
unknown_parent,
|
|
archive_full,
|
|
duplicate_organism,
|
|
unknown_organism,
|
|
already_dead,
|
|
invalid_identity,
|
|
invalid_tick
|
|
};
|
|
inline constexpr std::size_t max_archived_genomes = 4'096;
|
|
inline constexpr std::size_t max_archived_organisms = 65'536;
|
|
|
|
// Retains genomes and the organisms that carried them. There is no removal
|
|
// operation: not a guarded one, not a private one. Retention is a property of
|
|
// this interface rather than a rule a caller has to remember.
|
|
class LineageArchive {
|
|
public:
|
|
LineageArchive() = default;
|
|
// Copyable: cloning an archive takes nothing away from the original, and
|
|
// GENOME_MODEL expects migrations to be rehearsed on cloned worlds.
|
|
// Declaring the copy constructor also suppresses the implicit moves, so a
|
|
// move decays to a copy and a moved-from archive still holds every record.
|
|
LineageArchive(const LineageArchive&) = default;
|
|
// Not assignable, in either form. Assignment is a removal operation that is
|
|
// simply not named like one: it discards every record the target holds. It
|
|
// would also let a copy taken earlier be written back, restoring an organism
|
|
// already recorded as dead, and death is terminal.
|
|
LineageArchive& operator=(const LineageArchive&) = delete;
|
|
LineageArchive& operator=(LineageArchive&&) = delete;
|
|
|
|
// A parent must already be present, so ancestry never dangles and the parent
|
|
// graph cannot contain a cycle: a cycle would need a member admitted first.
|
|
[[nodiscard]] std::expected<void, HistoryError> admit(const Genome& genome);
|
|
[[nodiscard]] std::expected<void, HistoryError> record_birth(std::uint64_t organism,
|
|
std::uint64_t genome, Tick when);
|
|
// Terminal for the organism, and nothing to do with the genome it carried.
|
|
[[nodiscard]] std::expected<void, HistoryError> record_death(std::uint64_t organism, Tick when);
|
|
|
|
[[nodiscard]] std::expected<Genome, HistoryError> find(std::uint64_t genome) const;
|
|
[[nodiscard]] std::expected<OrganismRecord, HistoryError>
|
|
organism(std::uint64_t identity) const;
|
|
// Oldest first, ending at the founder. Still resolves after every carrier dies.
|
|
[[nodiscard]] std::expected<std::vector<std::uint64_t>, HistoryError>
|
|
ancestry(std::uint64_t genome) const;
|
|
[[nodiscard]] std::expected<std::vector<std::uint64_t>, HistoryError>
|
|
children(std::uint64_t genome) const;
|
|
// Zero when the two descend from different founders.
|
|
[[nodiscard]] std::expected<std::uint64_t, HistoryError>
|
|
common_ancestor(std::uint64_t left, std::uint64_t right) const;
|
|
// Counted from the organism records themselves rather than kept alongside
|
|
// them, so there is no second tally that could drift out of agreement.
|
|
[[nodiscard]] std::expected<std::uint64_t, HistoryError>
|
|
living_carriers(std::uint64_t genome) const;
|
|
[[nodiscard]] std::expected<LineageStatus, HistoryError> status(std::uint64_t genome) const;
|
|
[[nodiscard]] std::size_t archived() const noexcept {
|
|
return genomes_.size();
|
|
}
|
|
[[nodiscard]] std::size_t recorded() const noexcept {
|
|
return organisms_.size();
|
|
}
|
|
|
|
private:
|
|
struct ArchivedOrganism {
|
|
std::uint64_t id;
|
|
OrganismRecord record;
|
|
};
|
|
// Held sorted by identity, so a lookup is a binary search and the archive
|
|
// keeps one record of each thing and no index that could disagree. Genomes
|
|
// are stored directly rather than in a wrapper: a genome is copy-only by
|
|
// ADR-0030, so an aggregate holding one would have a throwing move.
|
|
std::vector<Genome> genomes_;
|
|
std::vector<ArchivedOrganism> organisms_;
|
|
};
|
|
} // namespace evo::biology
|