ResourceAccount.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/StrongUint64.h"
 
#include <compare>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace eve::detail {
 
struct ResourceReservationIdTag {};
struct ResourceReceiptIdTag {};
 
}  // namespace eve::detail
 
namespace eve::resource {
 
class ResourceId {
public:
    ResourceId() = default;
 
    [[nodiscard]] static eve::Result<ResourceId> parse(std::string_view text);
 
    [[nodiscard]] bool isValid() const noexcept { return !value_.empty(); }
 
    [[nodiscard]] const std::string& value() const noexcept { return value_; }
 
    friend bool operator==(const ResourceId&, const ResourceId&) noexcept  = default;
    friend auto operator<=>(const ResourceId&, const ResourceId&) noexcept = default;
 
private:
    explicit ResourceId(std::string value) : value_(std::move(value)) {}
 
    std::string value_;
};
 
class Amount {
public:
    constexpr Amount() noexcept = default;
 
    explicit constexpr Amount(std::int64_t value) noexcept : value_(value) {}
 
    [[nodiscard]] static eve::Result<Amount> from(std::int64_t value);
 
    [[nodiscard]] static constexpr Amount zero() noexcept { return Amount(0); }
 
    [[nodiscard]] constexpr std::int64_t value() const noexcept { return value_; }
 
    [[nodiscard]] constexpr bool isZero() const noexcept { return value_ == 0; }
 
    [[nodiscard]] eve::Result<Amount> checkedAdd(Amount other) const;
 
    friend constexpr bool operator==(const Amount&, const Amount&) noexcept  = default;
    friend constexpr auto operator<=>(const Amount&, const Amount&) noexcept = default;
 
private:
    std::int64_t value_ = 0;
};
 
struct EVENGINE_API_FOUNDATION ResourceCost {
    ResourceId resource;
    Amount     amount;
 
    friend bool operator==(const ResourceCost&, const ResourceCost&) noexcept = default;
 
    [[nodiscard]] static eve::Result<ResourceCost> create(std::string_view resourceId, std::int64_t amountValue);
};
 
struct CostInput {
    std::string_view resource;
    std::int64_t     amount = 0;
};
 
class EVENGINE_API_FOUNDATION CostSpec {
public:
    CostSpec() = default;
 
    [[nodiscard]] static eve::Result<CostSpec> create(std::vector<ResourceCost> items);
 
    [[nodiscard]] static eve::Result<CostSpec> from(std::initializer_list<CostInput> items);
 
    [[nodiscard]] static eve::Result<CostSpec> single(std::string_view resource, std::int64_t amount);
 
    [[nodiscard]] bool isValid() const noexcept { return !items_.empty(); }
 
    [[nodiscard]] bool empty() const noexcept { return items_.empty(); }
 
    [[nodiscard]] const std::vector<ResourceCost>& items() const noexcept { return items_; }
 
    [[nodiscard]] std::size_t size() const noexcept { return items_.size(); }
 
    friend bool operator==(const CostSpec&, const CostSpec&) noexcept = default;
 
private:
    explicit CostSpec(std::vector<ResourceCost> items) : items_(std::move(items)) {}
 
    std::vector<ResourceCost> items_;
};
 
struct ResourceShortfall {
    ResourceId resource;
    Amount     required;
    Amount     available;
};
 
struct Affordability {
    bool                           affordable = false;
    std::vector<ResourceShortfall> shortfalls;
 
    [[nodiscard]] bool isAffordable() const noexcept { return affordable; }
};
 
enum class ReceiptOperation : std::uint8_t {
    Debit,
    Credit,
};
 
using ReservationId = eve::detail::StrongUint64<eve::detail::ResourceReservationIdTag>;
 
class AccountNonce {
public:
    constexpr AccountNonce() noexcept = default;
 
    [[nodiscard]] constexpr std::uint64_t value() const noexcept { return value_; }
 
    [[nodiscard]] constexpr bool isZero() const noexcept { return value_ == 0; }
 
    friend constexpr bool operator==(const AccountNonce&, const AccountNonce&) noexcept  = default;
    friend constexpr auto operator<=>(const AccountNonce&, const AccountNonce&) noexcept = default;
 
private:
    explicit constexpr AccountNonce(std::uint64_t value) noexcept : value_(value) {}
 
    friend EVENGINE_API_FOUNDATION eve::Result<AccountNonce> allocateAccountNonce();
 
    std::uint64_t value_ = 0;
};
 
using ReceiptId = eve::detail::StrongUint64<eve::detail::ResourceReceiptIdTag>;
 
[[nodiscard]] EVENGINE_API_FOUNDATION eve::Result<AccountNonce> allocateAccountNonce();
 
struct Reservation {
    AccountNonce  account;
    ReservationId id;
    CostSpec      cost;
 
    [[nodiscard]] bool isValid() const noexcept { return account.value() != 0 && id.value() != 0 && cost.isValid(); }
};
 
struct Receipt {
    AccountNonce     account;
    ReceiptId        id;
    ReservationId    reservation;
    ReceiptOperation operation = ReceiptOperation::Debit;
    CostSpec         cost;
 
    [[nodiscard]] bool isValid() const noexcept { return account.value() != 0 && id.value() != 0 && cost.isValid(); }
};
 
class IResourceAccount {
public:
    virtual ~IResourceAccount() = default;
 
    [[nodiscard]] virtual eve::Result<Affordability> canAfford(const CostSpec& cost) const = 0;
 
    [[nodiscard]] virtual eve::Result<Reservation> reserve(const CostSpec& cost) = 0;
 
    [[nodiscard]] virtual eve::Result<Receipt> debit(const CostSpec& cost) = 0;
 
    [[nodiscard]] virtual eve::Result<Receipt> credit(const CostSpec& cost) = 0;
 
    [[nodiscard]] virtual eve::Result<Receipt> commit(const Reservation& reservation) = 0;
 
    [[nodiscard]] virtual eve::Result<void> rollback(const Reservation& reservation) = 0;
};
 
}  // namespace eve::resource
 
namespace std {
 
template <>
struct hash<eve::resource::ResourceId> {
    std::size_t operator()(const eve::resource::ResourceId& value) const noexcept {
        return std::hash<std::string>{}(value.value());
    }
};
 
}  // namespace std