interface.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <string_view>
 
#include "cppfig/diff.h"
#include "cppfig/setting.h"
 
namespace cppfig {
 
template <typename Derived, typename Schema>
class IConfigurationProvider {
public:
    using schema_type = Schema;
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    [[nodiscard]] auto Get() const -> typename S::value_type
    {
        return static_cast<const Derived*>(this)->template GetImpl<S>();
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    auto Set(typename S::value_type value) -> Status
    {
        return static_cast<Derived*>(this)->template SetImpl<S>(std::move(value));
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    [[nodiscard]] auto IsOverridden() const -> bool
    {
        return static_cast<const Derived*>(this)->template IsOverriddenImpl<S>();
    }
 
    [[nodiscard]] auto Load() -> Status { return static_cast<Derived*>(this)->LoadImpl(); }
 
    [[nodiscard]] auto Save() const -> Status { return static_cast<const Derived*>(this)->SaveImpl(); }
 
    [[nodiscard]] auto Diff() const -> ConfigDiff { return static_cast<const Derived*>(this)->DiffImpl(); }
 
    [[nodiscard]] auto ValidateAll() const -> Status
    {
        return static_cast<const Derived*>(this)->ValidateAllImpl();
    }
 
    [[nodiscard]] auto GetFilePath() const -> std::string_view
    {
        return static_cast<const Derived*>(this)->GetFilePathImpl();
    }
 
protected:
    IConfigurationProvider() = default;
    ~IConfigurationProvider() = default;
    IConfigurationProvider(const IConfigurationProvider&) = default;
    IConfigurationProvider(IConfigurationProvider&&) = default;
    auto operator=(const IConfigurationProvider&) -> IConfigurationProvider& = default;
    auto operator=(IConfigurationProvider&&) -> IConfigurationProvider& = default;
};
 
class IConfigurationProviderVirtual {
public:
    virtual ~IConfigurationProviderVirtual() = default;
 
    [[nodiscard]] virtual auto Load() -> Status = 0;
 
    [[nodiscard]] virtual auto Save() const -> Status = 0;
 
    [[nodiscard]] virtual auto GetFilePath() const -> std::string_view = 0;
 
    [[nodiscard]] virtual auto ValidateAll() const -> Status = 0;
 
    [[nodiscard]] virtual auto GetDiffString() const -> std::string = 0;
 
protected:
    IConfigurationProviderVirtual() = default;
    IConfigurationProviderVirtual(const IConfigurationProviderVirtual&) = default;
    IConfigurationProviderVirtual(IConfigurationProviderVirtual&&) = default;
    auto operator=(const IConfigurationProviderVirtual&) -> IConfigurationProviderVirtual& = default;
    auto operator=(IConfigurationProviderVirtual&&) -> IConfigurationProviderVirtual& = default;
};
 
template <typename ConfigT>
class VirtualConfigAdapter final : public IConfigurationProviderVirtual {
public:
    explicit VirtualConfigAdapter(ConfigT& config)
        : config_(&config)
    {
    }
 
    [[nodiscard]] auto Load() -> Status override { return config_->Load(); }
 
    [[nodiscard]] auto Save() const -> Status override { return config_->Save(); }
 
    [[nodiscard]] auto GetFilePath() const -> std::string_view override { return config_->GetFilePath(); }
 
    [[nodiscard]] auto ValidateAll() const -> Status override { return config_->ValidateAll(); }
 
    [[nodiscard]] auto GetDiffString() const -> std::string override { return config_->Diff().ToString(); }
 
private:
    ConfigT* config_;
};
 
}  // namespace cppfig