Two defects from review of 8584eb1.
Genome had implicit move operations, so moving one emptied the source's
capabilities while leaving its identity, origin and digest intact. The
result still reported its ID but no longer encoded to decodable bytes,
which contradicts the documented invariant that an invalid genome cannot
exist. Declaring the copy operations suppresses the implicit moves, so a
move decays to a copy and the invariant holds for every operation. The
record is at most seven capabilities and one parent, so the copy is cheap.
The move tests were confirmed to fail without the fix: Debug and ASan
exit 1 at runtime, and Release does not compile, because MSVC proves the
moved-from comparison always throws and rejects the unreachable code.
clang-tidy then flagged the deliberate decaying moves; those lines carry
a NOLINT explaining that the decay is the contract under test.
The encoding tests compared the current encoder against the current
decoder, so a coordinated change to layout or digest would have passed
while breaking existing v1 records. A frozen 83-byte fixture now holds
one schema 1 founder record, asserted in both directions: the encoder
must still produce those bytes and the decoder must still read them. Every
structural byte was verified by hand against schemas/genome-v1.md before
freezing. It is a golden, not a value to update when a test fails.
Native Release, clang-tidy analysis, ASan and format checks pass 17/17.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
145 lines
5.2 KiB
C++
145 lines
5.2 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <compare>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <expected>
|
|
#include <span>
|
|
#include <vector>
|
|
|
|
namespace evo::biology {
|
|
// Evolvable developmental capabilities, not genes, organs, species or DNA.
|
|
enum class Capability : std::uint8_t {
|
|
energy_conversion,
|
|
membrane,
|
|
movement,
|
|
ingestion,
|
|
reproduction,
|
|
target_size,
|
|
thermal_tolerance
|
|
};
|
|
inline constexpr std::size_t capability_count = 7;
|
|
// The unit is a schema fact per kind and is never encoded, so no record can
|
|
// contradict its own units.
|
|
enum class Unit : std::uint8_t {
|
|
per_thousand,
|
|
micrometres,
|
|
micrometres_per_tick,
|
|
femtograms,
|
|
femtograms_per_tick,
|
|
millikelvin
|
|
};
|
|
struct CapabilitySpec {
|
|
Unit unit;
|
|
std::uint32_t minimum;
|
|
std::uint32_t maximum;
|
|
bool required;
|
|
// Capabilities the schema mandates be present; developmental edges as well.
|
|
std::uint32_t mandates;
|
|
};
|
|
[[nodiscard]] constexpr std::uint32_t capability_bit(Capability kind) noexcept {
|
|
return 1U << static_cast<std::uint8_t>(kind);
|
|
}
|
|
// Chosen schema constants, reviewable as a unit. These are ranges of expressible
|
|
// capability, not balance, stats or a power score.
|
|
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema{
|
|
CapabilitySpec{Unit::per_thousand, 1, 1000, true, 0},
|
|
CapabilitySpec{Unit::micrometres, 1, 10'000, true, 0},
|
|
CapabilitySpec{Unit::micrometres_per_tick, 0, 100'000, false,
|
|
capability_bit(Capability::membrane)},
|
|
CapabilitySpec{Unit::femtograms_per_tick, 0, 1'000'000, false,
|
|
capability_bit(Capability::membrane)},
|
|
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
|
|
capability_bit(Capability::energy_conversion)},
|
|
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
|
|
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
|
|
|
|
struct CapabilityRecord {
|
|
Capability kind{};
|
|
std::uint32_t parameter{};
|
|
// Declared developmental ordering, over and above what the schema mandates.
|
|
std::uint32_t prerequisites{};
|
|
auto operator<=>(const CapabilityRecord&) const = default;
|
|
};
|
|
// Unvalidated input. Only Genome::create turns one into a record.
|
|
struct GenomeDraft {
|
|
std::uint64_t id{};
|
|
std::uint64_t origin_event{};
|
|
std::uint32_t development_version{};
|
|
std::vector<std::uint64_t> parents;
|
|
std::vector<CapabilityRecord> capabilities;
|
|
};
|
|
enum class GenomeError : std::uint8_t {
|
|
unsupported_version,
|
|
unknown_capability,
|
|
missing_capability,
|
|
duplicate_capability,
|
|
parameter_out_of_range,
|
|
missing_prerequisite,
|
|
cyclic_development,
|
|
invalid_identity,
|
|
invalid_ancestry,
|
|
digest_mismatch,
|
|
invalid_encoding
|
|
};
|
|
inline constexpr std::uint32_t genome_schema_version = 1;
|
|
inline constexpr std::size_t max_parents = 2;
|
|
inline constexpr std::size_t max_genome_bytes = 256;
|
|
|
|
// Immutable once constructed: validation happens exactly once, at the boundary.
|
|
class Genome {
|
|
public:
|
|
[[nodiscard]] static std::expected<Genome, GenomeError> create(const GenomeDraft& draft);
|
|
[[nodiscard]] static std::expected<Genome, GenomeError>
|
|
decode(std::span<const std::uint8_t> bytes);
|
|
// Copy-only on purpose. A moved-from record would keep its identity, origin
|
|
// and digest while losing its capabilities, which is precisely the invalid
|
|
// genome this type exists to make unrepresentable. Declaring the copy
|
|
// operations suppresses the implicit moves, so a move decays to a copy; the
|
|
// record is at most seven capabilities and one parent, so that is cheap.
|
|
Genome(const Genome&) = default;
|
|
Genome& operator=(const Genome&) = default;
|
|
[[nodiscard]] std::vector<std::uint8_t> encode() const;
|
|
[[nodiscard]] std::uint64_t id() const noexcept {
|
|
return id_;
|
|
}
|
|
[[nodiscard]] std::uint64_t origin_event() const noexcept {
|
|
return origin_event_;
|
|
}
|
|
[[nodiscard]] std::uint32_t schema_version() const noexcept {
|
|
return genome_schema_version;
|
|
}
|
|
[[nodiscard]] std::uint32_t development_version() const noexcept {
|
|
return development_version_;
|
|
}
|
|
// Zero parents identifies a documented founder; v1 permits at most one.
|
|
[[nodiscard]] std::span<const std::uint64_t> parents() const noexcept {
|
|
return parents_;
|
|
}
|
|
// Sorted strictly ascending by kind, so the record is canonical.
|
|
[[nodiscard]] std::span<const CapabilityRecord> capabilities() const noexcept {
|
|
return capabilities_;
|
|
}
|
|
[[nodiscard]] bool carries(Capability kind) const noexcept;
|
|
[[nodiscard]] std::expected<std::uint32_t, GenomeError>
|
|
parameter(Capability kind) const noexcept;
|
|
// Covers identity and ancestry, so distinct origins never share a digest.
|
|
// An integrity and deduplication aid, never a content key and never authenticity.
|
|
[[nodiscard]] std::uint64_t content_digest() const noexcept {
|
|
return digest_;
|
|
}
|
|
auto operator<=>(const Genome&) const = default;
|
|
|
|
private:
|
|
Genome() = default;
|
|
[[nodiscard]] std::vector<std::uint8_t> body() const;
|
|
std::uint64_t id_{};
|
|
std::uint64_t origin_event_{};
|
|
std::uint32_t development_version_{};
|
|
std::vector<std::uint64_t> parents_;
|
|
std::vector<CapabilityRecord> capabilities_;
|
|
std::uint64_t digest_{};
|
|
};
|
|
} // namespace evo::biology
|