value.hpp

#pragma once
 
#include <unordered_map>
#include <vector>
#include <string>
#include <utility> // initializer_list, pair, swap
#include <cstddef> // size_t
 
extern "C" {
#include <launchdarkly/memory.h>
#include <launchdarkly/experimental/ldvalue.h>
}
 
namespace launchdarkly {
 
class Value;
class Array {
  public:
    ~Array();
    explicit Array();
    Array(std::initializer_list<Value>);
    Array(const Array&) = delete;
    Array(Array&&) = delete;
    Array& operator=(const Array&) = delete;
    Array& operator=(Array&&) noexcept = delete;
    friend bool operator== (const Array&, const Array&) = delete;
 
    Array& add(const Value&);
    Array& add(Value&&);
    Array& add(bool);
    Array& add(double);
    Array& add(const char *);
    Array& add(const std::string&);
 
    Value build() const;
  private:
    struct LDArray *ptr;
}; // class Array
 
 
 
class Object {
  public:
    ~Object();
    explicit Object();
    Object(std::initializer_list<std::pair<const char*, Value>>);
    Object(const Object&) = delete;
    Object(Object&&) = delete;
    Object& operator=(const Object&) = delete;
    Object& operator=(Object&&) noexcept = delete;
    friend bool operator== (const Object&, const Object&) = delete;
 
    void set(const char* key, const Value& value);
    void set(const char *key, Value&& value);
 
    void set(const char *key, bool value);
    void set(const char *key, double value);
    void set(const char *key, const char *value);
    void set(const char *key, const std::string& value);
 
    Value build() const;
  private:
    struct LDObject *ptr;
}; // class Object
 
class Value {
  public:
    enum class Type {
        Unrecognized,
        Null,
        Bool,
        Number,
        String,
        Array,
        Object
    };
 
    explicit Value(struct LDValue *ptr)
    :ptr{ptr} {}
 
    explicit Value()
    :ptr {LDValue_Null()} {}
 
    explicit Value(bool b)
    :ptr{LDValue_Bool(b ? LDBooleanTrue : LDBooleanFalse)} {}
 
    explicit Value(double b)
    :ptr { LDValue_Number(b) } {}
 
    explicit Value(const char *b)
    :ptr { LDValue_ConstantString(b)} {}
 
    explicit Value(const std::string& b)
    :ptr { LDValue_OwnedString(b.c_str())} {}
 
    Value(const Array& array)
    :ptr{ array.build().release() } {}
 
    Value(const Object& obj)
    :ptr{ obj.build().release() } {}
 
    Value(const Value& other)
    :ptr { LDValue_Clone(other.ptr) } {}
 
    Value(Value&& other) noexcept
    :ptr {other.release()} {}
 
    Value& operator=(const Value& other) {
        return *this = Value(other);
    }
 
    Value& operator=(Value&& other) noexcept
    {
        // destructor of other will free this object's previous ptr.
        std::swap(ptr, other.ptr);
        return *this;
    }
 
    ~Value() {
        LDValue_Free(ptr);
    }
 
 
    friend bool operator== (const Value& c1, const Value& c2) {
        return LDValue_Equal(c1.ptr, c2.ptr);
    }
 
    friend bool operator!= (const Value& c1, const Value& c2) {
        return !(c1 == c2);
    }
 
 
    Type type() const {
        switch (LDValue_Type(ptr)) {
        case LDValueType_Unrecognized:
            return Type::Unrecognized;
        case LDValueType_Null:
            return Type::Null;
        case LDValueType_Bool:
            return Type::Bool;
        case LDValueType_Number:
            return Type::Number;
        case LDValueType_String:
            return Type::String;
        case LDValueType_Array:
            return Type::Array;
        case LDValueType_Object:
            return Type::Object;
        }
    }
 
    std::string serialize_json() {
        char *serialized = LDValue_SerializeJSON(ptr);
        std::string r = serialized;
        LDFree(serialized);
        return r;
    }
 
    std::string serialize_formatted_json() {
        char *serialized = LDValue_SerializeFormattedJSON(ptr);
        std::string r = serialized;
        LDFree(serialized);
        return r;
    }
 
    static Value parse_json(const char *json) {
        struct LDValue* parsed = LDValue_ParseJSON(json);
        if (!parsed) {
            return Value();
        }
        return Value(parsed);
    }
 
    bool get_bool() const {
        return LDValue_GetBool(ptr);
    }
 
    std::string get_string() const {
        return LDValue_GetString(ptr);
    }
 
    double get_number() const {
        return LDValue_GetNumber(ptr);
    }
 
    std::vector<Value>
    into_vector() const {
        std::vector<Value> values;
        for (struct LDIter *it = LDValue_GetIter(ptr); it; it = LDIter_Next(it)) {
            values.emplace_back(LDValue_Clone(LDIter_Val(it)));
        }
        return values;
    }
 
    std::unordered_map<std::string, Value>
    into_unordered_map() const {
        std::unordered_map<std::string, Value> map;
        if (this->type() != Type::Object) {
            return map;
        }
        for (struct LDIter *it = LDValue_GetIter(ptr); it; it = LDIter_Next(it)) {
            map.emplace(LDIter_Key(it), LDValue_Clone(LDIter_Val(it)));
        }
        return map;
    }
 
    size_t count() const {
        return LDValue_Count(ptr);
    }
 
    bool is_null() const {
        return type() == Type::Null;
    }
 
    struct LDValue* release() {
        struct LDValue* raw = ptr;
        ptr = nullptr;
        return raw;
    }
 
 
  private:
    struct LDValue *ptr;
}; // class Value
 
 
Array::~Array() {
    LDArray_Free(ptr);
}
 
Array::Array() :ptr{LDArray_New()} {}
 
Array::Array(std::initializer_list<Value> init) :ptr{LDArray_New()} {
    for (auto copy : init) {
        LDArray_Add(ptr, copy.release());
    }
}
 
Array& Array::add(const Value& v) {
    Value clone {v};
    LDArray_Add(ptr, clone.release());
    return *this;
}
 
Array& Array::add(Value&& v) {
    LDArray_Add(ptr, v.release());
    return *this;
}
 
Array& Array::add(bool b) { add(Value(b)); return *this;}
Array& Array::add(double b) { add(Value(b)); return *this; }
Array& Array::add(const char *b) { add(Value(b)); return *this; }
Array& Array::add(const std::string& b) { add(Value(b)); return *this; }
 
Value Array::build() const {
    return Value(LDArray_Build(ptr));
}
 
 
Object::Object()
:ptr{LDObject_New()} {}
 
Object::Object(std::initializer_list<std::pair<const char*, Value>> init)
:ptr{LDObject_New()} {
    for (auto kv : init) {
        LDObject_AddConstantKey(ptr, kv.first, kv.second.release());
    }
}
 
Object::~Object() {
    LDObject_Free(ptr);
}
 
 
void Object::set(const char* key, const Value& value) {
    Value clone {value};
    LDObject_AddConstantKey(ptr, key, clone.release());
}
 
void Object::set(const char *key, Value&& value) {
    LDObject_AddConstantKey(ptr, key, value.release());
}
 
void Object::set(const char *key, bool value) { set(key, Value(value)); }
void Object::set(const char *key, double value) { set(key, Value(value)); }
void Object::set(const char *key, const char *val) { set(key, Value(val)); }
void Object::set(const char *key, const std::string& val) { set(key, Value(val)); }
 
Value Object::build() const {
    return Value(LDObject_Build(ptr));
}
 
} // namespace launchdarkly