value.hpp

#pragma once
 
#include <cstddef>
#include <map>
#include <optional>
#include <ostream>
#include <string>
#include <variant>
#include <vector>
 
namespace launchdarkly {
 
class Value final {
   public:
    class Array {
       public:
        struct Iterator {
            using iterator_category = std::bidirectional_iterator_tag;
            using difference_type = std::ptrdiff_t;
            using value_type = Value;
            using pointer = value_type const*;
            using reference = value_type const&;
 
            Iterator(std::vector<Value>::const_iterator iterator);
 
            reference operator*() const;
            pointer operator->();
            Iterator& operator++();
            Iterator operator++(int);
 
            Iterator& operator--();
            Iterator operator--(int);
 
            friend bool operator==(Iterator const& lhs, Iterator const& rhs) {
                return lhs.iterator_ == rhs.iterator_;
            };
 
            friend bool operator!=(Iterator const& lhs, Iterator const& rhs) {
                return lhs.iterator_ != rhs.iterator_;
            };
 
           private:
            std::vector<Value>::const_iterator iterator_;
        };
 
        friend std::ostream& operator<<(std::ostream& out, Array const& arr) {
            out << "[";
            bool first = true;
            for (auto const& item : arr.vec_) {
                if (first) {
                    first = false;
                } else {
                    out << ", ";
                }
                out << item;
            }
            out << "]";
            return out;
        }
 
        Array(std::vector<Value> vec);
        Array(std::initializer_list<Value> values) : vec_(values) {}
        Array() = default;
 
        Value const& operator[](std::size_t index) const;
 
        [[nodiscard]] std::size_t Size() const;
 
        [[nodiscard]] Iterator begin() const;
 
        [[nodiscard]] Iterator end() const;
 
       private:
        std::vector<Value> vec_;
    };
 
    class Object {
       public:
        struct Iterator {
            using iterator_category = std::forward_iterator_tag;
            using difference_type = std::ptrdiff_t;
 
            using value_type = std::pair<std::string const, Value>;
            using pointer = value_type const*;
            using reference = value_type const&;
 
            Iterator(std::map<std::string, Value>::const_iterator iterator);
 
            reference operator*() const;
            pointer operator->();
            Iterator& operator++();
            Iterator operator++(int);
 
            friend bool operator==(Iterator const& lhs, Iterator const& rhs) {
                return rhs.it_ == lhs.it_;
            };
            friend bool operator!=(Iterator const& lhs, Iterator const& rhs) {
                return lhs.it_ != rhs.it_;
            };
 
           private:
            std::map<std::string, Value>::const_iterator it_;
        };
 
        friend std::ostream& operator<<(std::ostream& out, Object const& obj) {
            out << "{";
            bool first = true;
            for (auto const& pair : obj.map_) {
                if (first) {
                    first = false;
                } else {
                    out << ", ";
                }
                out << "{" << pair.first << ", " << pair.second << "}";
            }
            out << "}";
            return out;
        }
 
        Object(std::map<std::string, Value> map) : map_(std::move(map)) {}
        Object() = default;
        Object(std::initializer_list<std::pair<std::string, Value>> values);
 
        /*
         * Get the Value with the specified key.
         *
         * This operates like `.at` on a map, and accessing out of bounds
         * is invalid.
         */
        Value const& operator[](std::string const& key) const;
 
        [[nodiscard]] std::size_t Size() const;
 
        [[nodiscard]] std::size_t Count(std::string const& key) const;
 
        [[nodiscard]] Iterator begin() const;
 
        [[nodiscard]] Iterator end() const;
 
        [[nodiscard]] Iterator Find(std::string const& key) const;
 
       private:
        std::map<std::string, Value> map_;
    };
 
    Value(char const* str);
 
    enum class Type { kNull, kBool, kNumber, kString, kObject, kArray };
 
    Value();
 
    Value(Value const& val) = default;
    Value(Value&&) = default;
    Value& operator=(Value const&) = default;
    Value& operator=(Value&&) = default;
 
    Value(bool boolean);
 
    Value(double num);
 
    Value(int num);
 
    Value(std::string str);
 
    Value(std::vector<Value> arr);
 
    Value(Array arr);
 
    Value(Object obj);
 
    Value(std::map<std::string, Value> obj);
 
    Value(std::initializer_list<Value> values);
 
    Value(std::optional<std::string> opt_string);
 
    [[nodiscard]] Type Type() const;
 
    [[nodiscard]] bool IsNull() const;
 
    [[nodiscard]] bool IsBool() const;
 
    [[nodiscard]] bool IsNumber() const;
 
    [[nodiscard]] bool IsString() const;
 
    [[nodiscard]] bool IsArray() const;
 
    [[nodiscard]] bool IsObject() const;
 
    [[nodiscard]] bool AsBool() const;
 
    [[nodiscard]] int AsInt() const;
 
    [[nodiscard]] double AsDouble() const;
 
    [[nodiscard]] std::string const& AsString() const;
 
    [[nodiscard]] Array const& AsArray() const;
 
    [[nodiscard]] Object const& AsObject() const;
 
    ~Value() = default;
 
    static Value const& Null();
 
    friend std::ostream& operator<<(std::ostream& out, Value const& value) {
        switch (value.Type()) {
            case Type::kNull:
                out << "null()";
                break;
            case Type::kBool:
                out << "bool("
                    << (std::get<bool>(value.storage_) ? "true" : "false")
                    << ")";
                break;
            case Type::kNumber:
                out << "number(" << std::get<double>(value.storage_) << ")";
                break;
            case Type::kString:
                out << "string(" << std::get<std::string>(value.storage_)
                    << ")";
                break;
            case Type::kObject:
                out << "object(" << std::get<Object>(value.storage_) << ")";
                break;
            case Type::kArray:
                out << "array(" << std::get<Array>(value.storage_) << ")";
                break;
        }
        return out;
    }
 
    operator bool() const { return AsBool(); }
 
    operator std::string() const { return AsString(); }
 
    operator double() const { return AsDouble(); }
 
    operator int() const { return AsInt(); }
 
   private:
    struct null_type {};
 
    std::variant<null_type, bool, double, std::string, Array, Object> storage_;
 
    // Empty constants used when accessing the wrong type.
    // These are not inline static const because of this bug:
    // https://developercommunity.visualstudio.com/t/inline-static-destructors-are-called-multiple-time/1157794
    static std::string const empty_string_;
    static Array const empty_vector_;
    static Object const empty_map_;
    static Value const null_value_;
};
 
bool operator==(Value const& lhs, Value const& rhs);
bool operator!=(Value const& lhs, Value const& rhs);
 
bool operator==(Value::Array const& lhs, Value::Array const& rhs);
bool operator!=(Value::Array const& lhs, Value::Array const& rhs);
 
bool operator==(Value::Object const& lhs, Value::Object const& rhs);
bool operator!=(Value::Object const& lhs, Value::Object const& rhs);
 
/* Returns true if both values are numbers and lhs < rhs. Returns false if
 * either value is not a number.
 */
bool operator<(Value const& lhs, Value const& rhs);
 
/* Returns true if both values are numbers and lhs > rhs. Returns false if
 * either value is not a number.
 */
bool operator>(Value const& lhs, Value const& rhs);
 
/* Returns true if both values are numbers and lhs <= rhs. Returns false if
 * either value is not a number.
 */
bool operator<=(Value const& lhs, Value const& rhs);
 
/* Returns true if both values are numbers and lhs >= rhs. Returns false if
 * either value is not a number.
 */
bool operator>=(Value const& lhs, Value const& rhs);
 
}  // namespace launchdarkly