SBAny.hpp

//
//  SBAny.hpp
//  SwitchboardSDK
//
//  Copyright © 2026 Synervoz. All rights reserved.
//
 
#pragma once
 
#include "switchboard/export.h"
#include <initializer_list>
#include <utility>
#include <string>
#include <any>
#include <map>
#include <optional>
#include <string>
#include <variant>
#include <vector>
#include <functional>
#include <cstdint>
 
 
namespace switchboard {
 
template <typename T>
class Result;
 
class SBAnyMap;
class SBAnyVector;

enum class SBAnyType : uint32_t {
    Null, 
    Bool, 
    Int, 
    Float, 
    Double, 
    String, 
    Vector, 
    Map, 
    Function, 
    Pointer 
};

class SWITCHBOARDSDK_EXPORT SBAny final {
public:
    // Default constructor - Null type
    SBAny();
    SBAny(std::monostate);
 
    // Boolean type
    SBAny(bool);
 
    // Integer types
    SBAny(int32_t);
    SBAny(int64_t);
    SBAny(uint32_t);
    SBAny(uint64_t);
 
    // SFINAE to avoid ambiguity with int32_t and int64_t
    static constexpr bool int_is_distinct =
        !std::is_same<int, int32_t>::value &&
        !std::is_same<int, int64_t>::value;
    template<bool Enable = int_is_distinct,
             typename std::enable_if<Enable, int>::type = 0>
    SBAny(int value) : SBAny(static_cast<int64_t>(value)) {}
 
    static constexpr bool uint_is_distinct =
        !std::is_same<unsigned int, uint32_t>::value &&
        !std::is_same<unsigned int, uint64_t>::value;
    template<bool Enable = uint_is_distinct,
             typename std::enable_if<Enable, int>::type = 0>
    SBAny(unsigned int value) : SBAny(static_cast<uint64_t>(value)) {}
 
    // Floating point types
    SBAny(float);
    SBAny(double);
 
    // String types
    SBAny(const char* utf8);
    SBAny(const std::string& str);
 
    // Map type
    SBAny(std::initializer_list<std::pair<std::string, SBAny>> init);
    SBAny(const SBAnyMap& init);
 
    // Vector type
    // SBAny(std::vector<SBAny> init);
    SBAny(const SBAnyVector& init);
    explicit SBAny(std::initializer_list<SBAny> init);
 
    // Function wrapper constructors
    SBAny(std::function<Result<SBAny>()> init); // Property Getter
    SBAny(std::function<SBAny()> init); // Property Getter (no failure)
    SBAny(std::function<Result<void>(const SBAny&)> init); // Property Setter
    SBAny(std::function<void(const SBAny&)> init); // Property Setter (no failure)
    SBAny(std::function<Result<SBAny>(const SBAnyMap&)> init); // Action
 
    // Pointers
    SBAny(float* init);
 
    // Copy constructor and assignment
    SBAny(const SBAny&);
    SBAny& operator=(const SBAny&);
 
    ~SBAny();

    SBAnyType type() const noexcept;

    std::any toAny() const;

    void* toPtr() const;

    template <typename T>
    static T convert(const SBAny& value);
 
private:
    struct Impl;
    Impl* pimpl;
};

class SWITCHBOARDSDK_EXPORT SBAnyVector final {
public:
    SBAnyVector();

    SBAnyVector(const SBAnyVector& init);

    SBAnyVector& operator=(const SBAnyVector& other);

    template<typename Iterator>
    SBAnyVector(Iterator first, Iterator last);

    template<typename T>
    explicit SBAnyVector(const std::vector<T>& vec) : SBAnyVector() {
        reserve(vec.size());
        for (const auto& item : vec) {
            emplace_back(SBAny(item));
        }
    }

    explicit SBAnyVector(std::initializer_list<SBAny> init);

    ~SBAnyVector();

    void reserve(size_t newCapacity);

    [[nodiscard]] size_t size() const;

    void emplace_back(const SBAny& value);

    void push_back(const SBAny& value);

    SBAny& operator[](size_t index);

    const SBAny& operator[](size_t index) const;
 
    // Iterators
    using iterator = std::vector<SBAny>::iterator;
    using const_iterator = std::vector<SBAny>::const_iterator;
 
    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
 
private:
    struct Impl;
    Impl* pimpl;
};

class SWITCHBOARDSDK_EXPORT SBAnyMap {
public:
    SBAnyMap();

    SBAnyMap(const std::string& jsonString);

    SBAnyMap(const SBAnyMap& other);

    SBAnyMap& operator=(const SBAnyMap& other);

    SBAnyMap(std::initializer_list<std::pair<std::string, SBAny>> init);

    ~SBAnyMap();

    [[nodiscard]] bool hasKey(const std::string& key) const;

    [[nodiscard]] bool empty() const;

    [[nodiscard]] size_t size() const;

    [[nodiscard]] SBAny getAny(const std::string& key) const;

    [[nodiscard]] SBAny at(const std::string& key) const;

    template <typename T>
    [[nodiscard]] T get(const std::string& key) const;

    void set(const std::string& key, const SBAny& value);

    void erase(const std::string& key);

    template <typename T>
    static T get(const SBAnyMap& map, const std::string& key, std::optional<T> defaultValue = std::nullopt);

    static SBAnyMap jsonToMap(const std::string& jsonString);

    static std::string mapToJson(const SBAnyMap& map);
 
    // Iterators
    using iterator = std::map<std::string, SBAny>::iterator;
    using const_iterator = std::map<std::string, SBAny>::const_iterator;
 
    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
 
    // Operator overloads
    SBAny& operator[](const std::string& key);
    const SBAny& operator[](const std::string& key) const;
 
private:
    struct Impl;
    Impl* pimpl;
};
 
}