SzCoreEnvironment.hpp

Go to the documentation of this file.

// SzCoreEnvironment.hpp -- native-backed SzEnvironment implementation + builder.
//
// Ports core/SzCoreEnvironment.cs. Owns one lazily-created, cached instance of
// each subsystem, guarded by a mutex. Get* accessors call EnsureActive() (which
// throws SzEnvironmentDestroyedException after Destroy()) and return a non-owning
// reference to the env-owned subsystem.
//
// All accessors are implemented: GetProduct, GetEngine, GetConfigManager,
// GetDiagnostic, plus Destroy, IsDestroyed, GetActiveConfigID, and Reinitialize.
#ifndef SENZING_SDK_CORE_SZCOREENVIRONMENT_HPP
#define SENZING_SDK_CORE_SZCOREENVIRONMENT_HPP
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
 
#include "senzing/sdk/SzEnvironment.hpp"
 
namespace senzing::sdk::core {
 
class SzCoreProduct;
class SzCoreConfigManager;
class SzCoreDiagnostic;
class SzCoreEngine;
 
class SzCoreEnvironment final : public SzEnvironment {
public:
    static constexpr const char* kDefaultInstanceName = "Senzing Instance";
    static constexpr const char* kDefaultSettings = "{ }";
 
    class Builder {
    public:
        Builder& InstanceName(const std::string& instanceName);
        Builder& Settings(const std::string& settings);
        Builder& VerboseLogging(bool verboseLogging);
        Builder& ConfigID(int64_t configID);
        std::unique_ptr<SzCoreEnvironment> Build();
 
    private:
        std::string instanceName_{kDefaultInstanceName};
        std::string settings_{kDefaultSettings};
        bool verboseLogging_{false};
        std::optional<int64_t> configID_;
    };
 
    static Builder NewBuilder();
 
    static SzCoreEnvironment* GetActiveInstance();
 
    ~SzCoreEnvironment() override;
 
    SzCoreEnvironment(const SzCoreEnvironment&) = delete;
    SzCoreEnvironment& operator=(const SzCoreEnvironment&) = delete;
 
    // ---- SzEnvironment ----
    SzProduct& GetProduct() override;
    SzEngine& GetEngine() override;
    SzConfigManager& GetConfigManager() override;
    SzDiagnostic& GetDiagnostic() override;
    int64_t GetActiveConfigID() override;
    void Reinitialize(int64_t configID) override;
    void Destroy() override;
    bool IsDestroyed() override;
 
    // ---- Internal accessors used by owned subsystems ----
    [[nodiscard]] const std::string& GetInstanceName() const noexcept;
    [[nodiscard]] const std::string& GetSettings() const noexcept;
    [[nodiscard]] bool IsVerboseLogging() const noexcept;
 
    [[nodiscard]] std::optional<int64_t> GetConfigID() const noexcept;
 
    void EnsureActive();
 
private:
    SzCoreEnvironment(std::string instanceName, std::string settings,
                      bool verboseLogging, std::optional<int64_t> configID);
 
    void EnsureActiveLocked() const;
 
    SzCoreEngine& EnsureEngine();
 
    std::string instanceName_;
    std::string settings_;
    bool verboseLogging_;
    std::optional<int64_t> configID_;
 
    mutable std::mutex monitor_;
    bool destroyed_{false};
 
    // Per-process singleton enforcement (mirrors C# active-instance pattern).
    static std::mutex s_classMutex_;
    static SzCoreEnvironment* s_activeInstance_;
 
    std::unique_ptr<SzCoreProduct> coreProduct_;
    std::unique_ptr<SzCoreConfigManager> coreConfigManager_;
    std::unique_ptr<SzCoreDiagnostic> coreDiagnostic_;
    std::unique_ptr<SzCoreEngine> coreEngine_;
};
 
}  // namespace senzing::sdk::core
 
#endif  // SENZING_SDK_CORE_SZCOREENVIRONMENT_HPP