client.hpp

#pragma once
 
#include <chrono>
#include <future>
#include <memory>
#include <string>
#include <unordered_map>
 
#include <launchdarkly/context.hpp>
#include <launchdarkly/value.hpp>
 
#include <launchdarkly/client_side/data_source_status.hpp>
#include <launchdarkly/client_side/flag_notifier.hpp>
#include <launchdarkly/config/client.hpp>
#include <launchdarkly/data/evaluation_detail.hpp>
 
namespace launchdarkly::client_side {
 
class IClient {
   public:
    using FlagKey = std::string;
 
    virtual std::future<bool> StartAsync() = 0;
 
    [[nodiscard]] virtual bool Initialized() const = 0;
 
    [[nodiscard]] virtual std::unordered_map<FlagKey, Value> AllFlags()
        const = 0;
 
    virtual void Track(std::string event_name,
                       Value data,
                       double metric_value) = 0;
 
    virtual void Track(std::string event_name, Value data) = 0;
 
    virtual void Track(std::string event_name) = 0;
 
    virtual void FlushAsync() = 0;
 
    virtual std::future<bool> IdentifyAsync(Context context) = 0;
 
    virtual bool BoolVariation(FlagKey const& key, bool default_value) = 0;
 
    virtual EvaluationDetail<bool> BoolVariationDetail(FlagKey const& key,
                                                       bool default_value) = 0;
 
    virtual std::string StringVariation(FlagKey const& key,
                                        std::string default_value) = 0;
 
    virtual EvaluationDetail<std::string> StringVariationDetail(
        FlagKey const& key,
        std::string default_value) = 0;
 
    virtual double DoubleVariation(FlagKey const& key,
                                   double default_value) = 0;
 
    virtual EvaluationDetail<double> DoubleVariationDetail(
        FlagKey const& key,
        double default_value) = 0;
 
    virtual int IntVariation(FlagKey const& key, int default_value) = 0;
 
    virtual EvaluationDetail<int> IntVariationDetail(FlagKey const& key,
                                                     int default_value) = 0;
 
    virtual Value JsonVariation(FlagKey const& key, Value default_value) = 0;
 
    virtual EvaluationDetail<Value> JsonVariationDetail(
        FlagKey const& key,
        Value default_value) = 0;
 
    virtual data_sources::IDataSourceStatusProvider& DataSourceStatus() = 0;
 
    virtual flag_manager::IFlagNotifier& FlagNotifier() = 0;
 
    virtual ~IClient() = default;
    IClient(IClient const& item) = delete;
    IClient(IClient&& item) = delete;
    IClient& operator=(IClient const&) = delete;
    IClient& operator=(IClient&&) = delete;
 
   protected:
    IClient() = default;
};
 
class Client : public IClient {
   public:
    Client(Config config, Context context);
 
    Client(Client&&) = delete;
    Client(Client const&) = delete;
    Client& operator=(Client) = delete;
    Client& operator=(Client&& other) = delete;
 
    std::future<bool> StartAsync() override;
 
    [[nodiscard]] bool Initialized() const override;
 
    using FlagKey = std::string;
    [[nodiscard]] std::unordered_map<FlagKey, Value> AllFlags() const override;
 
    void Track(std::string event_name,
               Value data,
               double metric_value) override;
 
    void Track(std::string event_name, Value data) override;
 
    void Track(std::string event_name) override;
 
    void FlushAsync() override;
 
    std::future<bool> IdentifyAsync(Context context) override;
 
    bool BoolVariation(FlagKey const& key, bool default_value) override;
 
    EvaluationDetail<bool> BoolVariationDetail(FlagKey const& key,
                                               bool default_value) override;
 
    std::string StringVariation(FlagKey const& key,
                                std::string default_value) override;
 
    EvaluationDetail<std::string> StringVariationDetail(
        FlagKey const& key,
        std::string default_value) override;
 
    double DoubleVariation(FlagKey const& key, double default_value) override;
 
    EvaluationDetail<double> DoubleVariationDetail(
        FlagKey const& key,
        double default_value) override;
 
    int IntVariation(FlagKey const& key, int default_value) override;
 
    EvaluationDetail<int> IntVariationDetail(FlagKey const& key,
                                             int default_value) override;
 
    Value JsonVariation(FlagKey const& key, Value default_value) override;
 
    EvaluationDetail<Value> JsonVariationDetail(FlagKey const& key,
                                                Value default_value) override;
 
    data_sources::IDataSourceStatusProvider& DataSourceStatus() override;
 
    flag_manager::IFlagNotifier& FlagNotifier() override;
 
    [[nodiscard]] static char const* Version();
 
   private:
    inline static char const* const kVersion =
        "3.5.0";  // {x-release-please-version}
    std::unique_ptr<IClient> client;
};
 
}  // namespace launchdarkly::client_side