Contract.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <string>
#include <vector>
#include <utility>
 
#include "core/domain/policies/AliasPolicy.h"
#include "core/domain/values/ContractType.h"
#include "core/domain/values/EntityName.h"
#include "core/domain/values/Alias.h"
 
namespace core::domain {
 
class Contract {
public:
    Contract();
 
    Contract(const Contract&) = delete;
    Contract& operator=(const Contract&) = delete;
    Contract(Contract&&) = delete;
    Contract& operator=(Contract&&) = delete;

    void rename(EntityName value);
    void rename(std::string value);

    void setType(ContractType value);
    void setType(std::string value);
    void setAllocatableMode(std::string value);

    void setActorIds(std::vector<std::string> value);

    void addActorId(std::string value);

    void removeActorId(const std::string& value);

    void clearActorIds();

    void setPropertyIds(std::vector<std::string> value);

    void addPropertyId(std::string value);

    void removePropertyId(const std::string& value);

    void clearPropertyIds();

    void addAlias(Alias value);

    void removeAlias(std::string value);

    void recordAliasHit(std::string value, std::string timestamp = {});

    [[nodiscard]] bool hasName() const noexcept;

    [[nodiscard]] bool hasAlias(const std::string& value) const;

    [[nodiscard]] std::size_t aliasCount() const noexcept;

    [[nodiscard]] bool hasAliases() const noexcept;

    void clearAliases();

    [[nodiscard]] bool containsActorId(const std::string& value) const;

    [[nodiscard]] bool containsPropertyId(const std::string& value) const;

    [[nodiscard]] bool hasSingleActor() const noexcept;

    [[nodiscard]] bool hasActorRelations() const noexcept;

    [[nodiscard]] bool hasPropertyRelations() const noexcept;

    [[nodiscard]] bool hasRelations() const noexcept;

    [[nodiscard]] std::size_t relationCount() const noexcept;

    [[nodiscard]] std::size_t actorCount() const noexcept;

    [[nodiscard]] std::size_t propertyCount() const noexcept;

    [[nodiscard]] bool hasType() const noexcept;

    [[nodiscard]] bool isConfigured() const noexcept;

    [[nodiscard]] bool isMatchingReady() const noexcept;

    [[nodiscard]] bool isStandalone() const noexcept;
 
private:
    static void normalizeIds(std::vector<std::string>& values) {
        std::vector<std::string> unique;
        unique.reserve(values.size());
        for (auto& value : values) {
            value = policies::alias::trimCopy(std::move(value));
            if (value.empty()) continue;
            if (std::find(unique.begin(), unique.end(), value) != unique.end()) continue;
            unique.push_back(value);
        }
        values = std::move(unique);
    }
 
    std::string id_;
    std::string name_;
    std::string type_;
    std::string allocatableMode_ = "mixed";
    std::vector<std::string> actorIds_;
    std::vector<std::string> propertyIds_;
    std::vector<Alias> aliases_;
    std::string createdAt_;
    std::string updatedAt_;
 
public:
    // Read accessors
    [[nodiscard]] const std::string& id() const noexcept;
    [[nodiscard]] const std::string& name() const noexcept;
    [[nodiscard]] const std::string& type() const noexcept;
    [[nodiscard]] const std::string& allocatableMode() const noexcept;
    [[nodiscard]] const std::vector<std::string>& actorIds() const noexcept;
    [[nodiscard]] const std::vector<std::string>& propertyIds() const noexcept;
    [[nodiscard]] const std::vector<Alias>& aliases() const noexcept;
    [[nodiscard]] const std::string& createdAt() const noexcept;
    [[nodiscard]] const std::string& updatedAt() const noexcept;
 
    // Technical hydration
    void setId(std::string value);
    void setAliases(std::vector<Alias> value);
    void setCreatedAt(std::string value);
    void setUpdatedAt(std::string value);
};
 
} // namespace core::domain