client.hpp

#pragma once
 
#include <launchdarkly/context.hpp>
#include <launchdarkly/data/evaluation_detail.hpp>
#include <launchdarkly/server_side/config/config.hpp>
#include <launchdarkly/value.hpp>
 
#include <launchdarkly/server_side/all_flags_state.hpp>
#include <launchdarkly/server_side/data_source_status.hpp>
 
#include <chrono>
#include <future>
#include <memory>
#include <string>
#include <unordered_map>
 
namespace launchdarkly::server_side {
class IClient {
   public:
    using FlagKey = std::string;
 
    virtual std::future<bool> StartAsync() = 0;
 
    [[nodiscard]] virtual bool Initialized() const = 0;
 
    [[nodiscard]] virtual class AllFlagsState AllFlagsState(
        Context const& context,
        AllFlagsState::Options options = AllFlagsState::Options::Default) = 0;
 
    virtual void Track(Context const& ctx,
                       std::string event_name,
                       Value data,
                       double metric_value) = 0;
 
    virtual void Track(Context const& ctx,
                       std::string event_name,
                       Value data) = 0;
 
    virtual void Track(Context const& ctx, std::string event_name) = 0;
 
    virtual void FlushAsync() = 0;
 
    virtual void Identify(Context context) = 0;
 
    virtual bool BoolVariation(Context const& ctx,
                               FlagKey const& key,
                               bool default_value) = 0;
 
    virtual EvaluationDetail<bool> BoolVariationDetail(Context const& ctx,
                                                       FlagKey const& key,
                                                       bool default_value) = 0;
 
    virtual std::string StringVariation(Context const& ctx,
                                        FlagKey const& key,
                                        std::string default_value) = 0;
 
    virtual EvaluationDetail<std::string> StringVariationDetail(
        Context const& ctx,
        FlagKey const& key,
        std::string default_value) = 0;
 
    virtual double DoubleVariation(Context const& ctx,
                                   FlagKey const& key,
                                   double default_value) = 0;
 
    virtual EvaluationDetail<double> DoubleVariationDetail(
        Context const& ctx,
        FlagKey const& key,
        double default_value) = 0;
 
    virtual int IntVariation(Context const& ctx,
                             FlagKey const& key,
                             int default_value) = 0;
 
    virtual EvaluationDetail<int> IntVariationDetail(Context const& ctx,
                                                     FlagKey const& key,
                                                     int default_value) = 0;
 
    virtual Value JsonVariation(Context const& ctx,
                                FlagKey const& key,
                                Value default_value) = 0;
 
    virtual EvaluationDetail<Value> JsonVariationDetail(
        Context const& ctx,
        FlagKey const& key,
        Value default_value) = 0;
 
    virtual IDataSourceStatusProvider& DataSourceStatus() = 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);
 
    std::future<bool> StartAsync() override;
 
    [[nodiscard]] bool Initialized() const override;
 
    using FlagKey = std::string;
    [[nodiscard]] class AllFlagsState AllFlagsState(
        Context const& context,
        enum AllFlagsState::Options options =
            AllFlagsState::Options::Default) override;
 
    void Track(Context const& ctx,
               std::string event_name,
               Value data,
               double metric_value) override;
 
    void Track(Context const& ctx, std::string event_name, Value data) override;
 
    void Track(Context const& ctx, std::string event_name) override;
 
    void FlushAsync() override;
 
    void Identify(Context context) override;
 
    bool BoolVariation(Context const& ctx,
                       FlagKey const& key,
                       bool default_value) override;
 
    EvaluationDetail<bool> BoolVariationDetail(Context const& ctx,
                                               FlagKey const& key,
                                               bool default_value) override;
 
    std::string StringVariation(Context const& ctx,
                                FlagKey const& key,
                                std::string default_value) override;
 
    EvaluationDetail<std::string> StringVariationDetail(
        Context const& ctx,
        FlagKey const& key,
        std::string default_value) override;
 
    double DoubleVariation(Context const& ctx,
                           FlagKey const& key,
                           double default_value) override;
 
    EvaluationDetail<double> DoubleVariationDetail(
        Context const& ctx,
        FlagKey const& key,
        double default_value) override;
 
    int IntVariation(Context const& ctx,
                     FlagKey const& key,
                     int default_value) override;
 
    EvaluationDetail<int> IntVariationDetail(Context const& ctx,
                                             FlagKey const& key,
                                             int default_value) override;
 
    Value JsonVariation(Context const& ctx,
                        FlagKey const& key,
                        Value default_value) override;
 
    EvaluationDetail<Value> JsonVariationDetail(Context const& ctx,
                                                FlagKey const& key,
                                                Value default_value) override;
 
    IDataSourceStatusProvider& DataSourceStatus() override;
 
    [[nodiscard]] static char const* Version();
 
   private:
    inline static char const* const kVersion =
        "3.8.0";  // {x-release-please-version}
    std::unique_ptr<IClient> client;
};
 
}  // namespace launchdarkly::server_side