template< typename > class Allocator

Allocator type (defaults to std::allocator)

basic_variable();

A default constructed variable contains null, which means it has no value.

basic_variable(const basic_variable & element);

basic_variable(basic_variable && element) noexcept;

template<typename T> basic_variable(T);

T must be a supported type, otherwise a compilation error occurs.

basic_variable(const std::initializer_list< value_type > & elements);

If the initializer list elements contains an array of pairs then the variable will be of type map, otherwise of type array.

basic_variable(const nullable &);

basic_variable(const char *);

basic_variable(const wchar_t *);

basic_variable(const char16_t *);

basic_variable(const char32_t *);

basic_variable(const typename basic_variable::array_type &);

Re-construct a variable from the value returned by assume_value.

Prefer to use factory or initializer-lists when creating arrays.

basic_variable(typename basic_variable::array_type &&);

Re-construct a variable from the value returned by assume_value.

Prefer to use factory or initializer-lists when creating arrays.

basic_variable(const typename basic_variable::map_type &);

Re-construct a variable from the value returned by assume_value.

Prefer to use factory or initializer-lists when creating associative arrays.

basic_variable(typename basic_variable::map_type &&);

Re-construct a variable from the value returned by assume_value.

Prefer to use factory or initializer-lists when creating associative arrays.

basic_variable & operator=(const basic_variable &);

basic_variable & operator=(basic_variable &&);

template<typename T> basic_variable & operator=(T);

basic_variable & operator=(nullable);

basic_variable & operator=(const char *);

basic_variable & operator=(const wchar_t *);

basic_variable & operator=(const char16_t *);

basic_variable & operator=(const char32_t *);

basic_variable & operator+=(const basic_variable &);

The append operator has different meanings depending on the types.

template<typename T> basic_variable & operator+=(const T &);

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

basic_variable & operator+=(const char *);

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

basic_variable & operator+=(const wchar_t *);

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

basic_variable & operator+=(const char16_t *);

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

basic_variable & operator+=(const char32_t *);

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T> T value() const;

Calls basic_variable<Allocator>::value<T>(std::error_code&) and throws an exception if an error occurred.

See Also:

basic_variable<Allocator>::value<T>(std::error_code&)

template<typename T> T value(std::error_code & error) const noexcept;

T can either be a type or a tag.

If current tag is dynamic::integer or dynamic::real, then T can be any arithmetic type. Such a conversion may result in loss of precision.

If current tag is any other type, then T must be the associated type.

If T is a tag, then the following types are used.

template<typename R> explicit operator R() const;

Calls basic_variable<Allocator>::value<R>()

See Also:

basic_variable<Allocator>::value<T>()

template<typename R> R & assume_value();

assume_value() has a narrow contract. Using a type R that does not match the type of the stored value results in undefined behavior.

template<typename R> const R & assume_value() const;

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

basic_variable & operator[](size_type position);

The stored value must be an array.

No bounds-checking is performed.

const basic_variable & operator[](size_type position) const;

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

basic_variable & operator[](const typename map_type::key_type & key);

Returns a reference to the value associated with key in an associative array, or inserts a key of none exists.

If the current tag is nullable, then the current value is changed into an associative array and key is inserted.

const basic_variable & 
operator[](const typename map_type::key_type & key) const;

Returns a reference to the value associated with key in an associative array.

template<typename T> bool is() const noexcept;

Converts T into a tag, and returns true if variable has the same tag, otherwise returns false.

If T is a tag, then this tag is used directly: variable v = true; // Boolean assert(v.is<boolean>());

If T is a C++ type, then this is converted a tag: variable v = true; // Boolean assert(v.is<bool>()); // Same as is<boolean>()

The type-to-tag conversion means that any type from the same category can be used: variable v = 2; // Integer assert(v.is<int>()); // Same as is<integer>() assert(v.is<long int>()); // Same as is<integer>()

Checking for an array or a map can either be done by a tag: variable v = { 1, 2, 3}; // Array assert(v.is<array>());

or by the unspecified variable::array_type or variable::map_type type aliases: variable v = { 1, 2, 3}; // Array assert(v.is<variable::array_type>());

Using unsupported types will result in a compilation error.

template<typename T> bool same() const noexcept;

Returns true if variable has the exact same type as T, otherwise returns false. variable v = int(2); // int assert(v.same<int>() == true); // Same as int assert(v.same<long int>() == false); // Not same as long int

dynamic::code::value code() const noexcept;

Code is an enumerator that represents the exact type that is currently stored.

dynamic::symbol::value symbol() const noexcept;

Symbol is an enumerator that represents the tag of the type currently stored.

bool empty() const noexcept;

Same as size() == 0

size_type size() const noexcept;

The number of elements stored in a variable corresponds to the iteration count, that is v.size() == std::distance(v.begin(), v.end()).

Notice that strings are regarded as single elements, rather than a sequence of characters.

size_type max_size() const noexcept;

void clear() noexcept;

Only the value is cleared. The type is not modified.

iterator insert(const basic_variable & element);

template<typename InputIterator> 
  void insert(InputIterator begin, InputIterator end);

iterator insert(const_iterator position, const basic_variable & element);

template<typename InputIterator> 
  void insert(const_iterator, InputIterator begin, InputIterator end);

iterator erase(const_iterator position);

Returns iterator following last erased element.

iterator erase(const_iterator begin, const_iterator end);

Returns iterator following last erased element.

void swap(basic_variable & other) noexcept;

iterator begin();

const_iterator begin() const;

const_iterator cbegin() const;

iterator end();

const_iterator end() const;

const_iterator cend() const;

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

const_reverse_iterator crbegin() const;

reverse_iterator rend();

const_reverse_iterator rend() const;

const_reverse_iterator crend() const;

key_iterator key_begin() const;

key_iterator key_end() const;