Content

Variant

Stores a varying type values. If you use Variant type item multiple time(in loop, for example) don't forget to clear it before each use to prevent appearing of waste data from prev state.

You can find more information in comments below.

class Variant
{
public:
    enum class VariantType // Variant data types
    {
        Pointer, // void*
        Bool, // bool
        Integer, // int
        UnsignedInteger, // unsigned int
        Float, // float
        String, // String
        Map, // A list of key -> value associations. Where key is a String and value is Variant
        Array // An array of variants
    };
public:
    Variant(); // Create empty(type is vtPointer and value is nullptr)
    Variant(void *value); // Create with specified pointer value
    Variant(const bool value); // Create with specified bool value
    Variant(const int value); // Create with specified int value
    Variant(const unsigned int value); // Create with specified unsigned int value
    Variant(const float value); // Create with specified float value
    Variant(const String &value); // Create with specified String value
    Variant(const Variant &other) = default;
    Variant(Variant &&other) = default;

    VariantType getType() const; // Return type
    bool isSet(const String &key) const; // Check whether element with specified name exists
    bool inArray(const Variant &value) const; // Check whether specified value is in array of elements

    bool operator==(const Variant &other) const; // Check whether variants are equal
    bool operator!=(const Variant &other) const; // Check whether variants are not equal

    void operator=(void *value); // Set pointer value
    void operator=(const bool value); // Set bool value
    void operator=(const int value); // Set int value
    void operator=(const unsigned int value); // Set unsigned int value
    void operator=(const float value); // Set float value
    void operator=(const String &value); // Set String value
    Variant &operator=(const Variant &other) = default;
    Variant &operator=(Variant &&other) = default;

    operator void*() const; // Return as pointer
    operator bool() const; // Return as bool
    operator int() const; // Return as int
    operator unsigned int() const; // Return as unsigned int
    operator float() const; // Return as float
    operator String() const; // Return as String

    Variant &operator[](const wchar_t *key); // Get element by name. Create new empty one if not found
    Variant operator[](const int key); //  // Get element by index. Create new empty one if not found or Variant isn't an array or a map

    // Standard iterators
    Map::iterator begin();
    Map::iterator end();
    Map::const_iterator begin() const;
    Map::const_iterator end() const;
    Map::const_iterator cbegin() const;
    Map::const_iterator cend() const;

    // Standard reverse iterators
    Map::reverse_iterator rbegin();
    Map::reverse_iterator rend();
    Map::const_reverse_iterator rbegin() const;
    Map::const_reverse_iterator rend() const;
    Map::const_reverse_iterator crbegin() const;
    Map::const_reverse_iterator crend() const;

    Map::size_type size() const; // Return number of elements
    bool empty() const; // Make it empty
    Map::iterator erase(Map::const_iterator _Where); // Erase element at specified position
    Map::iterator erase(Map::const_iterator _First, Map::const_iterator _Last); // Erase specified range of elements
    void clear(); // Clear all elements
    Map::const_iterator find(const String &_Keyval) const; // Find element by name
    void push_back(const Variant &value); // Add element

    Variant get(const wchar_t *key) const; // Safely get map/array item by name. If doesn't exist, return null variant
    Variant get(const int index) const; // Safely get map/array item by index. If doesn't exist, return null variant

    void Reset(); // Remove all elements, set type to Pointer, and set value to nullptr
    String Stringify(); // Return json encoded string representing the Variant
#ifdef _DEBUG
    void Print(const AnsiString &spaces = "") const;
#endif
};