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
    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 
    explicit Variant(); // Create empty(type is vtPointer and value is nullptr) 
    explicit Variant(void *value); // Create with specified pointer value 
    explicit Variant(const bool value); // Create with specified bool value 
    explicit Variant(const int value); // Create with specified int value 
    explicit Variant(const unsigned int value); // Create with specified unsigned int value 
    explicit Variant(const float value); // Create with specified float value 
    explicit 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;

    explicit operator void*() const; // Return as pointer 
    explicit operator bool() const; // Return as bool 
    explicit operator int() const; // Return as int 
    explicit operator unsigned int() const; // Return as unsigned int 
    explicit operator float() const; // Return as float 
    explicit 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;
Namespace: nitisa
Include: Nitisa/Core/Variant.h