EditorAssetDatabase.cpp

浏览该文件的文档.

#include "editor/EditorAssetDatabase.h"
 
#include <algorithm>
#include <cctype>
#include <set>
 
namespace eve::editor {
namespace {
 
bool containsInsensitive(std::string value, std::string text) {
    auto lower = [](unsigned char character) { return static_cast<char>(std::tolower(character)); };
    std::transform(value.begin(), value.end(), value.begin(), lower);
    std::transform(text.begin(), text.end(), text.begin(), lower);
    return value.find(text) != std::string::npos;
}
 
}  // namespace
 
Result<AssetRecord> MemoryAssetDatabase::publish(AssetRecord record, std::vector<AssetDependency> dependencies) {
    if (record.guid.empty() || record.logicalUri.empty() || record.typeId.empty())
        return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.asset.invalid-record"),
                                                 "Asset GUID, logical URI and type are required");
    const auto uriOwner = uriToGuid_.find(record.logicalUri);
    if (uriOwner != uriToGuid_.end() && uriOwner->second != record.guid)
        return eve::editing::failed<AssetRecord>(EditorStatus::Conflict, RuleId("editor.asset.uri-conflict"),
                                                 "Another asset already owns this logical URI");
    for (const AssetDependency& dependency : dependencies) {
        if (dependency.from != record.guid || dependency.to.empty())
            return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.asset.invalid-dependency"),
                                                     "Published dependencies must originate from the product asset");
    }
    record.status       = AssetStatus::Ready;
    const auto existing = records_.find(record.guid);
    if (existing != records_.end() && existing->second.logicalUri != record.logicalUri)
        uriToGuid_.erase(existing->second.logicalUri);
    uriToGuid_.insert_or_assign(record.logicalUri, record.guid);
    records_.insert_or_assign(record.guid, record);
    std::erase_if(dependencies_, [&](const AssetDependency& dependency) { return dependency.from == record.guid; });
    dependencies_.insert(dependencies_.end(), dependencies.begin(), dependencies.end());
    ++generation_;
    return eve::editing::applied<AssetRecord>(std::move(record));
}
 
Result<std::vector<AssetRecord>> MemoryAssetDatabase::publishBatch(
    std::vector<AssetPublication> publications) {
    if (publications.empty())
        return eve::editing::failed<std::vector<AssetRecord>>(EditorStatus::Rejected,
                                                              RuleId("editor.asset.empty-publication"),
                                                              "An asset publication batch must not be empty");
    auto stagedRecords      = records_;
    auto stagedUris         = uriToGuid_;
    auto stagedDependencies = dependencies_;
    std::vector<AssetRecord> published;
    std::unordered_map<AssetGuid, bool, StrongEditorIdHash<AssetGuid>> batchGuids;
    published.reserve(publications.size());
    for (AssetPublication& publication : publications) {
        AssetRecord& record = publication.record;
        if (record.guid.empty() || record.logicalUri.empty() || record.typeId.empty())
            return eve::editing::failed<std::vector<AssetRecord>>(EditorStatus::Rejected,
                                                                  RuleId("editor.asset.invalid-record"),
                                                                  "Asset GUID, logical URI and type are required");
        if (!batchGuids.emplace(record.guid, true).second)
            return eve::editing::failed<std::vector<AssetRecord>>(
                EditorStatus::Conflict, RuleId("editor.asset.duplicate-batch-guid"),
                "An asset publication batch contains a duplicate GUID");
        const auto uriOwner = stagedUris.find(record.logicalUri);
        if (uriOwner != stagedUris.end() && uriOwner->second != record.guid)
            return eve::editing::failed<std::vector<AssetRecord>>(EditorStatus::Conflict,
                                                                  RuleId("editor.asset.uri-conflict"),
                                                                  "Another asset already owns this logical URI");
        for (const AssetDependency& dependency : publication.dependencies) {
            if (dependency.from != record.guid || dependency.to.empty())
                return eve::editing::failed<std::vector<AssetRecord>>(
                    EditorStatus::Rejected, RuleId("editor.asset.invalid-dependency"),
                    "Published dependencies must originate from the product asset");
        }
        record.status       = AssetStatus::Ready;
        const auto existing = stagedRecords.find(record.guid);
        if (existing != stagedRecords.end() && existing->second.logicalUri != record.logicalUri)
            stagedUris.erase(existing->second.logicalUri);
        stagedUris.insert_or_assign(record.logicalUri, record.guid);
        stagedRecords.insert_or_assign(record.guid, record);
        std::erase_if(stagedDependencies,
                      [&](const AssetDependency& dependency) { return dependency.from == record.guid; });
        stagedDependencies.insert(stagedDependencies.end(), publication.dependencies.begin(),
                                  publication.dependencies.end());
        published.push_back(std::move(record));
    }
    records_      = std::move(stagedRecords);
    uriToGuid_    = std::move(stagedUris);
    dependencies_ = std::move(stagedDependencies);
    ++generation_;
    return eve::editing::applied<std::vector<AssetRecord>>(std::move(published));
}
 
Result<AssetRecord> MemoryAssetDatabase::find(const AssetGuid& guid) const {
    auto found = records_.find(guid);
    if (found == records_.end())
        return eve::editing::failed<AssetRecord>(EditorStatus::NotFound, RuleId("editor.asset.not-found"),
                                                 "Asset is not indexed: " + guid.value());
    return eve::editing::applied<AssetRecord>(found->second);
}
 
Result<AssetRecord> MemoryAssetDatabase::findByUri(const std::string& logicalUri) const {
    const auto guid = uriToGuid_.find(logicalUri);
    if (guid != uriToGuid_.end()) return find(guid->second);
    return eve::editing::failed<AssetRecord>(EditorStatus::NotFound, RuleId("editor.asset.not-found"),
                                             "Asset URI is not indexed: " + logicalUri);
}
 
Result<AssetPage<AssetRecord>> MemoryAssetDatabase::query(const AssetQuery& query, std::size_t offset,
                                                                std::size_t                  limit,
                                                                std::optional<std::uint64_t> generation) const {
    if (generation && *generation != generation_)
        return eve::editing::failed<AssetPage<AssetRecord>>(EditorStatus::Conflict, RuleId("editor.asset.page-expired"),
                                                            "Asset index changed while paging");
    std::vector<AssetRecord> matches;
    for (const auto& [guid, record] : records_) {
        (void)guid;
        if (query.status && record.status != *query.status) continue;
        if (!query.typeIds.empty() &&
            std::find(query.typeIds.begin(), query.typeIds.end(), record.typeId) == query.typeIds.end())
            continue;
        if (!query.pathPrefixes.empty()) {
            bool prefix = false;
            for (const std::string& candidate : query.pathPrefixes)
                if (record.logicalUri.starts_with(candidate)) prefix = true;
            if (!prefix) continue;
        }
        bool tags = true;
        for (const std::string& tag : query.tagsAll)
            if (std::find(record.tags.begin(), record.tags.end(), tag) == record.tags.end()) tags = false;
        if (!tags) continue;
        if (!query.text.empty() && !containsInsensitive(record.logicalUri, query.text) &&
            !containsInsensitive(record.typeId, query.text))
            continue;
        matches.push_back(record);
    }
    std::sort(matches.begin(), matches.end(),
              [](const AssetRecord& left, const AssetRecord& right) { return left.logicalUri < right.logicalUri; });
    AssetPage<AssetRecord> page;
    page.generation = generation_;
    if (offset < matches.size()) {
        const std::size_t end = std::min(matches.size(), offset + limit);
        page.values.assign(matches.begin() + static_cast<std::ptrdiff_t>(offset),
                           matches.begin() + static_cast<std::ptrdiff_t>(end));
        page.nextOffset = end;
        page.hasMore    = end < matches.size();
    }
    return eve::editing::applied<AssetPage<AssetRecord>>(std::move(page));
}
 
std::vector<AssetDependency> MemoryAssetDatabase::dependencies(const AssetGuid& guid, bool incoming) const {
    std::vector<AssetDependency> result;
    for (const AssetDependency& dependency : dependencies_)
        if ((incoming && dependency.to == guid) || (!incoming && dependency.from == guid)) result.push_back(dependency);
    return result;
}
 
Result<AssetRecord> ImportCoordinator::publish(ImportProduct product) {
    if (!database_)
        return eve::editing::failed<AssetRecord>(EditorStatus::Failed, RuleId("editor.import.missing-database"),
                                                 "Import coordinator has no asset database");
    if (product.record.sourceUri.empty() || product.record.importerId.empty())
        return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.import.invalid-product"),
                                                 "Import product requires source URI and importer identity");
    return database_->publish(std::move(product.record), std::move(product.dependencies));
}
 
Result<ImportTicket> ImportCoordinator::begin(const AssetGuid& asset, std::string sourceHash,
                                                    std::string importerId,
                                                    std::uint32_t importerVersion) {
    if (asset.empty() || sourceHash.empty() || importerId.empty() || importerVersion == 0)
        return eve::editing::failed<ImportTicket>(EditorStatus::Rejected, RuleId("editor.import.invalid-request"),
                                                  "Import request requires asset, source hash and versioned importer");
    const std::uint64_t generation = ++generations_[asset];
    return eve::editing::applied<ImportTicket>(
        {asset, generation, std::move(sourceHash), std::move(importerId), importerVersion});
}
 
Result<AssetRecord> ImportCoordinator::publish(const ImportTicket& ticket,
                                                     ImportProduct product) {
    if (!database_)
        return eve::editing::failed<AssetRecord>(EditorStatus::Failed, RuleId("editor.import.missing-database"),
                                                 "Import coordinator has no asset database");
    const auto generation = generations_.find(ticket.asset);
    if (generation == generations_.end() || generation->second != ticket.generation)
        return eve::editing::failed<AssetRecord>(EditorStatus::Conflict, RuleId("editor.import.stale-product"),
                                                 "Importer product was superseded by a newer source generation");
    AssetRecord& record = product.record;
    if (record.guid != ticket.asset || record.sourceHash != ticket.sourceHash ||
        record.importerId != ticket.importerId || record.importerVersion != ticket.importerVersion)
        return eve::editing::failed<AssetRecord>(EditorStatus::Conflict, RuleId("editor.import.ticket-mismatch"),
                                                 "Importer product identity does not match its request ticket");
    if (record.sourceUri.empty() || record.logicalUri.empty() || record.typeId.empty())
        return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.import.incomplete-product"),
                                                 "Importer product lacks source, logical URI or asset type");
    std::set<std::string> artifacts;
    for (const std::string& artifact : record.artifacts)
        if (artifact.empty() || !artifacts.insert(artifact).second)
            return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.import.invalid-artifact"),
                                                     "Importer artifacts must be unique and non-empty");
    if (record.artifacts.empty())
        return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.import.missing-artifact"),
                                                 "Importer product must contain at least one published artifact");
    if (std::any_of(record.diagnostics.begin(), record.diagnostics.end(),
                    [](const EditorDiagnostic& diagnostic) {
                        return diagnostic.severity() == DiagnosticSeverity::Error ||
                               diagnostic.severity() == DiagnosticSeverity::Fatal;
                    }))
        return eve::editing::failed<AssetRecord>(EditorStatus::Rejected, RuleId("editor.import.product-errors"),
                                                 "Importer product contains error diagnostics");
    auto published = database_->publish(std::move(record), std::move(product.dependencies));
    if (published.ok()) generations_.erase(ticket.asset);
    return published;
}
 
}  // namespace eve::editor