EVEngine/InventorySaveSession_8cpp_source.html

#include "inventory/InventorySaveSession.h"


#include "common/Value.h"

#include "inventory/Bag.h"

#include "inventory/Equipment.h"

#include "inventory/InventorySystem.h"

#include "inventory/Item.h"


#include <algorithm>

#include <cmath>

#include <memory>

#include <unordered_set>


namespace eve::inventory {


namespace {


double number(const eve::Value &value) {

    return value.isInt64() ? static_cast<double>(value.asInt()) : value.asDouble();

}


eve::Value encodeStrings(const std::vector<std::string> &values) {

    eve::Value::Array encoded;

    encoded.reserve(values.size());

    for (const auto &value : values) encoded.emplace_back(value);

    return eve::Value(std::move(encoded));

}


eve::Value encodeMap(const std::unordered_map<std::string, std::string> &values) {

    eve::Value::Object encoded;

    for (const auto &[key, value] : values) encoded.emplace(key, eve::Value(value));

    return eve::Value(std::move(encoded));

}


eve::Value encodeStack(const ItemStack &stack) {

    eve::Value::Object encoded;

    encoded.emplace("durability", eve::Value(stack.durability));

    encoded.emplace("instanceId", eve::Value(stack.instanceId));

    encoded.emplace("itemId", eve::Value(stack.itemId));

    encoded.emplace("props", encodeMap(stack.props));

    encoded.emplace("quantity", eve::Value(stack.quantity));

    encoded.emplace("tags", encodeStrings(stack.tags));

    return eve::Value(std::move(encoded));

}


eve::Result<std::vector<std::string>> decodeStrings(const eve::Value *encoded, const std::string &path) {

    if (!encoded || !encoded->isArray())

        return eve::Result<std::vector<std::string>>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "expected an array of strings", path));

    std::vector<std::string> result;

    std::unordered_set<std::string> seen;

    result.reserve(encoded->arraySize());

    for (std::size_t i = 0; i < encoded->arraySize(); ++i) {

        const auto &entry = encoded->at(i);

        if (!entry.isString() || entry.asString().empty() || !seen.emplace(entry.asString()).second)

            return eve::Result<std::vector<std::string>>::failure(eve::Diagnostic::error(

                eve::DiagnosticCode::InvalidArgument, "tag values must be non-empty and unique", path));

        result.push_back(entry.asString());

    }

    return eve::Result<std::vector<std::string>>::success(std::move(result));

}


eve::Result<std::unordered_map<std::string, std::string>> decodeMap(const eve::Value *encoded,

                                                                    const std::string &path) {

    if (!encoded || !encoded->isObject())

        return eve::Result<std::unordered_map<std::string, std::string>>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "expected a string map", path));

    std::unordered_map<std::string, std::string> result;

    for (const auto &key : encoded->keys()) {

        const eve::Value *value = encoded->find(key);

        if (key.empty() || !value || !value->isString())

            return eve::Result<std::unordered_map<std::string, std::string>>::failure(eve::Diagnostic::error(

                eve::DiagnosticCode::InvalidArgument, "map keys and values must be strings", path));

        result.emplace(key, value->asString());

    }

    return eve::Result<std::unordered_map<std::string, std::string>>::success(std::move(result));

}


eve::Result<ItemStack> decodeStack(const eve::Value &encoded, const std::string &path, int &largestId,

                                   std::unordered_set<int> &instanceIds) {

    if (!encoded.isObject())

        return eve::Result<ItemStack>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "item stack must be an object", path));

    const eve::Value *instanceId = encoded.find("instanceId");

    const eve::Value *itemId = encoded.find("itemId");

    const eve::Value *quantity = encoded.find("quantity");

    const eve::Value *durability = encoded.find("durability");

    if (!instanceId || !instanceId->isInt64() || !itemId || !itemId->isString() || !quantity ||

        !quantity->isInt64() || !durability || !durability->isNumeric() || !std::isfinite(number(*durability)))

        return eve::Result<ItemStack>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "item stack fields are invalid", path));


    auto props = decodeMap(encoded.find("props"), path + ".props");

    if (!props.ok()) return eve::Result<ItemStack>::failure(props.status());

    auto tags = decodeStrings(encoded.find("tags"), path + ".tags");

    if (!tags.ok()) return eve::Result<ItemStack>::failure(tags.status());


    ItemStack stack;

    stack.instanceId = static_cast<int>(instanceId->asInt());

    stack.itemId = itemId->asString();

    stack.quantity = static_cast<int>(quantity->asInt());

    stack.durability = static_cast<float>(number(*durability));

    stack.props = std::move(props).takeValue();

    stack.tags = std::move(tags).takeValue();

    if (stack.itemId.empty() || stack.quantity <= 0) {

        if (stack.instanceId != 0 || !stack.itemId.empty() || stack.quantity != 0 || stack.durability != -1.f ||

            !stack.props.empty() || !stack.tags.empty())

            return eve::Result<ItemStack>::failure(eve::Diagnostic::error(

                eve::DiagnosticCode::InvalidArgument, "empty item stack must use canonical empty values", path));

        return eve::Result<ItemStack>::success(std::move(stack));

    }


    const ItemDefinition *definition = ItemRegistry::find(stack.itemId);

    if (!definition)

        return eve::Result<ItemStack>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::NotFound,

                                   "item definition referenced by snapshot is not registered", path + ".itemId"));

    if (stack.instanceId <= 0 || stack.quantity > definition->maxStack || !instanceIds.emplace(stack.instanceId).second)

        return eve::Result<ItemStack>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::Conflict, "item identity or stack quantity is invalid", path));

    largestId = std::max(largestId, stack.instanceId);

    return eve::Result<ItemStack>::success(std::move(stack));

}


bool stackMatchesEquipmentSlot(const ItemStack &stack, const std::string &slot,

                               const std::vector<std::string> &allowedTags) {

    if (stack.empty()) return true;

    const ItemDefinition *definition = ItemRegistry::find(stack.itemId);

    if (!definition || (!definition->equipSlot.empty() && definition->equipSlot != slot)) return false;

    if (allowedTags.empty()) return true;

    for (const auto &tag : allowedTags) {

        if (definition->hasTag(tag) || stack.hasTag(tag)) return true;

    }

    return false;

}


}  // namespace


InventorySaveSession::PreparedRestore::PreparedRestore() = default;

InventorySaveSession::PreparedRestore::~PreparedRestore() = default;

InventorySaveSession::PreparedRestore::PreparedRestore(PreparedRestore &&) noexcept = default;

InventorySaveSession::PreparedRestore &InventorySaveSession::PreparedRestore::operator=(PreparedRestore &&) noexcept =

    default;


void InventorySaveSession::bind(Bag &bag, EquipmentSet &equipment) noexcept {

    bag_ = &bag;

    equipment_ = &equipment;

}


eve::Result<std::string> InventorySaveSession::snapshotJson() const {

    if (!bag_ || !equipment_)

        return eve::Result<std::string>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::PreconditionViolation, "inventory save session requires bound participants", {}));

    eve::Value::Array slots;

    slots.reserve(bag_->slots_.size());

    for (const auto &stack : bag_->slots_) slots.emplace_back(encodeStack(stack));

    eve::Value::Object bag;

    bag.emplace("acceptRule", eve::Value(bag_->acceptRule_));

    bag.emplace("acceptTags", encodeStrings(bag_->acceptTags_));

    bag.emplace("capacityPolicy", eve::Value(bag_->capacityPolicy_));

    bag.emplace("extra", encodeMap(bag_->extra_));

    bag.emplace("id", eve::Value(bag_->id_));

    bag.emplace("kind", eve::Value(bag_->kind_));

    bag.emplace("maxVolume", eve::Value(bag_->maxVolume_));

    bag.emplace("maxWeight", eve::Value(bag_->maxWeight_));

    bag.emplace("rejectTags", encodeStrings(bag_->rejectTags_));

    bag.emplace("slots", eve::Value(std::move(slots)));

    bag.emplace("stackRule", eve::Value(bag_->stackRule_));


    eve::Value::Array equipmentSlots;

    equipmentSlots.reserve(equipment_->order_.size());

    for (const auto &name : equipment_->order_) {

        const auto &slot = equipment_->slots_.at(name);

        eve::Value::Object encoded;

        encoded.emplace("allowedTags", encodeStrings(slot.allowedTags));

        encoded.emplace("name", eve::Value(name));

        encoded.emplace("stack", encodeStack(slot.stack));

        equipmentSlots.emplace_back(std::move(encoded));

    }

    eve::Value::Object equipment;

    equipment.emplace("id", eve::Value(equipment_->id_));

    equipment.emplace("slots", eve::Value(std::move(equipmentSlots)));


    eve::Value::Object root;

    root.emplace("bag", eve::Value(std::move(bag)));

    root.emplace("equipment", eve::Value(std::move(equipment)));

    root.emplace("schema", eve::Value("eve.inventory.save-session"));

    root.emplace("version", eve::Value(1));

    auto encoded = eve::Value(std::move(root)).toJson();

    if (!encoded.ok()) return encoded;

    auto validated = prepareRestoreSnapshotJson(encoded.value());

    if (!validated.ok()) return eve::Result<std::string>::failure(validated.status());

    return encoded;

}


eve::Result<InventorySaveSession::PreparedRestore> InventorySaveSession::prepareRestoreSnapshotJson(

    std::string_view json) const {

    if (!bag_ || !equipment_)

        return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::PreconditionViolation, "inventory save session requires bound participants", {}));

    InventorySystem::ensureBuiltins();

    auto parsed = eve::Value::fromJson(json);

    if (!parsed.ok()) return eve::Result<PreparedRestore>::failure(parsed.status());

    const eve::Value &root = parsed.value();

    const eve::Value *schema = root.isObject() ? root.find("schema") : nullptr;

    const eve::Value *version = root.isObject() ? root.find("version") : nullptr;

    if (!schema || !schema->isString() || schema->asString() != "eve.inventory.save-session")

        return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::InvalidArgument, "snapshot does not belong to InventorySaveSession", "$.schema"));

    if (!version || !version->isInt64() || version->asInt() != 1)

        return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::UnknownVersion, "unsupported inventory snapshot version", "$.version"));

    const eve::Value *bag = root.find("bag");

    const eve::Value *equipment = root.find("equipment");

    if (!bag || !bag->isObject() || !equipment || !equipment->isObject())

        return eve::Result<PreparedRestore>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "inventory participants must be objects", "$"));


    PreparedRestore candidate;

    const eve::Value *bagId = bag->find("id");

    const eve::Value *kind = bag->find("kind");

    const eve::Value *maxWeight = bag->find("maxWeight");

    const eve::Value *maxVolume = bag->find("maxVolume");

    const eve::Value *acceptRule = bag->find("acceptRule");

    const eve::Value *capacityPolicy = bag->find("capacityPolicy");

    const eve::Value *stackRule = bag->find("stackRule");

    const eve::Value *slots = bag->find("slots");

    if (!bagId || !bagId->isString() || !kind || !kind->isString() || kind->asString().empty() ||

        !maxWeight || !maxWeight->isNumeric() || !maxVolume || !maxVolume->isNumeric() ||

        !std::isfinite(number(*maxWeight)) || number(*maxWeight) < 0.0 || !std::isfinite(number(*maxVolume)) ||

        number(*maxVolume) < 0.0 || !acceptRule || !acceptRule->isString() || !capacityPolicy ||

        !capacityPolicy->isString() || !stackRule || !stackRule->isString() || !slots || !slots->isArray())

        return eve::Result<PreparedRestore>::failure(

            eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "bag configuration is invalid", "$.bag"));

    if (!InventorySystem::hasAcceptRule(acceptRule->asString()) ||

        !InventorySystem::hasCapacityPolicy(capacityPolicy->asString()) ||

        !InventorySystem::hasStackRule(stackRule->asString()))

        return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::NotFound, "bag snapshot references an unregistered policy", "$.bag"));

    auto preparedBag = std::make_unique<Bag>(static_cast<int>(slots->arraySize()));

    preparedBag->id_ = bagId->asString();

    preparedBag->kind_ = kind->asString();

    preparedBag->maxWeight_ = static_cast<float>(number(*maxWeight));

    preparedBag->maxVolume_ = static_cast<float>(number(*maxVolume));

    preparedBag->acceptRule_ = acceptRule->asString();

    preparedBag->capacityPolicy_ = capacityPolicy->asString();

    preparedBag->stackRule_ = stackRule->asString();

    auto acceptTags = decodeStrings(bag->find("acceptTags"), "$.bag.acceptTags");

    if (!acceptTags.ok()) return eve::Result<PreparedRestore>::failure(acceptTags.status());

    auto rejectTags = decodeStrings(bag->find("rejectTags"), "$.bag.rejectTags");

    if (!rejectTags.ok()) return eve::Result<PreparedRestore>::failure(rejectTags.status());

    auto extra = decodeMap(bag->find("extra"), "$.bag.extra");

    if (!extra.ok()) return eve::Result<PreparedRestore>::failure(extra.status());

    preparedBag->acceptTags_ = std::move(acceptTags).takeValue();

    preparedBag->rejectTags_ = std::move(rejectTags).takeValue();

    preparedBag->extra_ = std::move(extra).takeValue();


    std::unordered_set<int> instanceIds;

    for (std::size_t index = 0; index < slots->arraySize(); ++index) {

        auto stack = decodeStack(slots->at(index), "$.bag.slots[" + std::to_string(index) + "]",

                                 candidate.largestInstanceId, instanceIds);

        if (!stack.ok()) return eve::Result<PreparedRestore>::failure(stack.status());

        preparedBag->slots_[index] = std::move(stack).takeValue();

    }


    const eve::Value *equipmentId = equipment->find("id");

    const eve::Value *equipmentSlots = equipment->find("slots");

    if (!equipmentId || !equipmentId->isString() || !equipmentSlots || !equipmentSlots->isArray())

        return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::ParseError, "equipment configuration is invalid", "$.equipment"));

    auto preparedEquipment = std::make_unique<EquipmentSet>();

    preparedEquipment->id_ = equipmentId->asString();

    std::unordered_set<std::string> slotNames;

    for (std::size_t index = 0; index < equipmentSlots->arraySize(); ++index) {

        const eve::Value &encoded = equipmentSlots->at(index);

        const eve::Value *name = encoded.isObject() ? encoded.find("name") : nullptr;

        const eve::Value *stackValue = encoded.isObject() ? encoded.find("stack") : nullptr;

        if (!name || !name->isString() || name->asString().empty() ||

            !slotNames.emplace(name->asString()).second || !stackValue)

            return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

                eve::DiagnosticCode::InvalidArgument, "equipment slot identity is invalid", "$.equipment.slots"));

        auto allowed = decodeStrings(encoded.find("allowedTags"), "$.equipment.slots.allowedTags");

        if (!allowed.ok()) return eve::Result<PreparedRestore>::failure(allowed.status());

        auto stack = decodeStack(*stackValue, "$.equipment.slots[" + std::to_string(index) + "].stack",

                                 candidate.largestInstanceId, instanceIds);

        if (!stack.ok()) return eve::Result<PreparedRestore>::failure(stack.status());

        const std::string slotName = name->asString();

        auto allowedTags = std::move(allowed).takeValue();

        auto stackState = std::move(stack).takeValue();

        if (!stackMatchesEquipmentSlot(stackState, slotName, allowedTags))

            return eve::Result<PreparedRestore>::failure(eve::Diagnostic::error(

                eve::DiagnosticCode::Conflict, "equipped item violates its slot contract", "$.equipment.slots"));

        preparedEquipment->defineSlot(slotName);

        preparedEquipment->slots_.at(slotName).allowedTags = std::move(allowedTags);

        preparedEquipment->slots_.at(slotName).stack = std::move(stackState);

    }

    candidate.bag_ = std::move(preparedBag);

    candidate.equipment_ = std::move(preparedEquipment);

    return eve::Result<PreparedRestore>::success(std::move(candidate));

}


void InventorySaveSession::commitPrepared(PreparedRestore prepared) noexcept {

    bag_->id_.swap(prepared.bag_->id_);

    bag_->kind_.swap(prepared.bag_->kind_);

    std::swap(bag_->maxWeight_, prepared.bag_->maxWeight_);

    std::swap(bag_->maxVolume_, prepared.bag_->maxVolume_);

    bag_->acceptRule_.swap(prepared.bag_->acceptRule_);

    bag_->capacityPolicy_.swap(prepared.bag_->capacityPolicy_);

    bag_->stackRule_.swap(prepared.bag_->stackRule_);

    bag_->acceptTags_.swap(prepared.bag_->acceptTags_);

    bag_->rejectTags_.swap(prepared.bag_->rejectTags_);

    bag_->slots_.swap(prepared.bag_->slots_);

    bag_->extra_.swap(prepared.bag_->extra_);

    equipment_->id_.swap(prepared.equipment_->id_);

    equipment_->slots_.swap(prepared.equipment_->slots_);

    equipment_->order_.swap(prepared.equipment_->order_);

    InventorySystem::ensureNextInstanceIdAbove(prepared.largestInstanceId);

}


eve::Result<void> InventorySaveSession::restoreSnapshotJson(std::string_view json) {

    auto prepared = prepareRestoreSnapshotJson(json);

    if (!prepared.ok()) return eve::Result<void>::failure(prepared.status());

    commitPrepared(std::move(prepared).takeValue());

    return eve::Result<void>::success(eve::Status::success(eve::StatusCode::Applied));

}


}  // namespace eve::inventory

value
double value
Definition ActionNotifyRegistry.cpp:153

itemId
LogicalId itemId
Definition ActionTimelineWidget.cpp:28

root
int root
Definition AnimSmr.cpp:119

Bag.h

values
std::map< std::string, Var > values
Definition EditorHost.cpp:490

Equipment.h

key
std::uint32_t key
Definition GraphicsParticles.cpp:68

InventorySaveSession.h
Versioned atomic persistence boundary for one bag and equipment set.

InventorySystem.h

Item.h

kind
TokenKind kind
Definition LanguageIndex.cpp:17

name
std::string name
Definition McpScriptTools.cpp:40

tag
const std::string * tag
Definition ModuleAssembly.cpp:83

path
std::string path
Definition PlayHost.cpp:110

number
double number
Definition RpgDialect.cpp:332

slots
LocalPageCacheEntry slots[ShadowConfig::kLocalSlots]
Definition ShadowScheme.cpp:28

index
uint32_t index
Definition UnityVegetationMaterial.cpp:163

Value.h
Owning, renderer-independent dynamic values.

eve::Diagnostic::error
static Diagnostic error(DiagnosticCode code, std::string message, std::string path={}, DiagnosticDetails details={}, std::string source={})
Construct an error diagnostic with the standard error severity.
Definition Diagnostic.h:125

eve::Result
Move-only operation result carrying either a value or Status.
Definition Result.h:155

eve::Result::success
static Result success(T value)
Construct a successful result owning value.
Definition Result.h:164

eve::Result::failure
static Result failure(Status status)
Construct a failed result from a structured status.
Definition Result.h:175

eve::Status::success
static Status success(StatusCode code=StatusCode::Ok)
Construct a successful status with an explicit non-error outcome.
Definition Status.h:81

eve::Value
The canonical owning dynamic value used by data-facing protocols.
Definition Value.h:31

eve::Value::toJson
Result< std::string > toJson() const
Serialize this value as deterministic compact JSON.
Definition Value.cpp:67

eve::Value::asString
const std::string & asString() const
Return the string payload; the caller must have checked the kind.
Definition Value.cpp:87

eve::Value::isInt64
bool isInt64() const noexcept
Return true when this value is an Int64.
Definition Value.h:91

eve::Value::fromJson
static Result< Value > fromJson(std::string_view json)
Parse one strict JSON value into an owning Value.
Definition Value.cpp:57

eve::Value::Object
std::map< std::string, Value > Object
Definition Value.h:34

eve::Value::isNumeric
bool isNumeric() const noexcept
Return whether this value is an integer or finite number.
Definition Value.h:159

eve::Value::isArray
bool isArray() const noexcept
Return true when this value is an array.
Definition Value.h:97

eve::Value::isString
bool isString() const noexcept
Return true when this value is a string.
Definition Value.h:95

eve::Value::asInt
std::int64_t asInt() const
Return the Int64 payload; the caller must have checked the kind.
Definition Value.cpp:69

eve::Value::Array
std::vector< Value > Array
Definition Value.h:33

eve::Value::arraySize
std::size_t arraySize() const
Return the number of array elements.
Definition Value.cpp:100

eve::Value::isObject
bool isObject() const noexcept
Return true when this value is an object.
Definition Value.h:99

eve::Value::at
Value & at(std::size_t index)
Return a bounds-checked array element.
Definition Value.cpp:106

eve::Value::find
Value * find(const std::string &key) noexcept
Return an object member, or nullptr when absent.
Definition Value.cpp:124

eve::inventory::Bag
格子型物品容器（脚本可直接操作）。
Definition Bag.h:21

eve::inventory::EquipmentSet
EVENGINE_API_FOUNDATION public API.
Definition Equipment.h:19

eve::inventory::InventorySaveSession::PreparedRestore
Validated owning inventory state awaiting publication.
Definition InventorySaveSession.h:28

eve::inventory::InventorySaveSession::PreparedRestore::~PreparedRestore
~PreparedRestore()
Prepared restore.

eve::inventory::InventorySaveSession
Coordinates persistent inventory owners without duplicating their live state.
Definition InventorySaveSession.h:22

eve::inventory::InventorySaveSession::commitPrepared
void commitPrepared(PreparedRestore prepared) noexcept
Publish a previously validated state without failure or callbacks.
Definition InventorySaveSession.cpp:302

eve::inventory::InventorySaveSession::snapshotJson
eve::Result< std::string > snapshotJson() const
Capture the complete bag and equipment state.
Definition InventorySaveSession.cpp:150

eve::inventory::InventorySaveSession::prepareRestoreSnapshotJson
eve::Result< PreparedRestore > prepareRestoreSnapshotJson(std::string_view json) const
Parse and validate a snapshot without mutating either participant.
Definition InventorySaveSession.cpp:196

eve::inventory::InventorySaveSession::restoreSnapshotJson
eve::Result< void > restoreSnapshotJson(std::string_view json)
Validate and atomically restore both bound inventory participants.
Definition InventorySaveSession.cpp:320

eve::inventory::InventorySystem::ensureBuiltins
static void ensureBuiltins()
确保内置规则已注册（模块首次使用时自动调用）。
Definition InventorySystem.cpp:142

eve::inventory::InventorySystem::hasStackRule
static bool hasStackRule(const std::string &name)
True when stack rule.
Definition InventorySystem.cpp:126

eve::inventory::InventorySystem::hasAcceptRule
static bool hasAcceptRule(const std::string &name)
True when accept rule.
Definition InventorySystem.cpp:100

eve::inventory::InventorySystem::hasCapacityPolicy
static bool hasCapacityPolicy(const std::string &name)
True when capacity policy.
Definition InventorySystem.cpp:114

eve::inventory::ItemRegistry::find
static const ItemDefinition * find(const std::string &id)
Finds find.
Definition Item.cpp:53

eve::database::Value
std::variant< std::monostate, std::int64_t, double, std::string, bool > Value
Definition Database.h:26

eve::inventory
运行时容器：固定格数的背包 / 箱子 / 商店栏等。 行为由 InventorySystem 提供；本类暴露便于脚本绑定的薄封装方法。
Definition AvatarInstance.h:37

eve
Build metadata (engine git commit, build time, third-party version).
Definition Build.cpp:16

eve::DiagnosticCode::InvalidArgument
@ InvalidArgument

eve::DiagnosticCode::NotFound
@ NotFound

eve::DiagnosticCode::UnknownVersion
@ UnknownVersion

eve::DiagnosticCode::PreconditionViolation
@ PreconditionViolation

eve::DiagnosticCode::ParseError
@ ParseError

eve::DiagnosticCode::Conflict
@ Conflict

eve::StatusCode::Applied
@ Applied