Type of data that this variant object contains.

Get the currentVariant converted into a boolean.

Null, 0, 0.0, empty strings, empty vectors, empty maps, blobs of size 0, and "false" (case-sensitive) are all considered false. All other values are true.

Get the currentVariant converted into a floating-point number.

Only valid for fundamental types.

Special cases: If a Bool is true, this will return 1. All other cases will return 0.

Get the currentVariant converted into an integer.

Only valid for fundamental types.

Special cases: If a String can be parsed as a number via strtol(), it will be. If a Bool is true, this will return 1. All other cases (including non-fundamental types) will return 0.

Get the currentVariant converted into a string.

Only valid for fundamental types.

Special cases: Booleans will be returned as "true" or "false". Null will be returned as an empty string. The returned string may be either mutable or static, depending on the source type. All other cases will return an empty string.

Assigns an existing map which was allocated on the heap into theVariant without performing a copy.

This object will take over ownership of the map, and will set the std::map** you pass in to NULL.

TheVariant's type will be set to Map.

Assigns an existing string which was allocated on the heap into theVariant without performing a copy.

This object will take over ownership of the pointer, and will set the std::string* you pass in to NULL.

TheVariant's type will be set to MutableString.

Assigns an existing vector which was allocated on the heap into theVariant without performing a copy.

This object will take over ownership of the pointer, and will set the std::vector* you pass in to NULL.

TheVariant's type will be set to Vector.

Clear the givenVariant data, optionally into a new type.

Frees up any memory that might have been allocated. After calling this, you can access theVariant as the new type.

Construct a nullVariant.

TheVariant constructed will be of type Null.

Construct aVariant with the given templated type.

Valid types for this constructor areint,int64_t,float,double,bool,const char*, andchar* (but see below for additionalVariant types).

Typeint orint64_t:

• TheVariant constructed will be of type Int64.

Typedouble orfloat:

• TheVariant constructed will be of type Double.

Typebool:

• TheVariant constructed will be of type Bool.

Typeconst char*:

• TheVariant constructed will be of type StaticString, andis_string() will return true.Note: If you use this constructor, you must ensure that the memory pointed to stays valid for the life of theVariant, otherwise callmutable_string() orset_mutable_string(), which will copy the string to an internal buffer.

Typechar*:

• TheVariant constructed will be of type MutableString, andis_string() will return true.

Other types will result in compiler error unless using the following constructor overloads:

• std::string
• std::vector<Variant>
• std::vector where T is convertible to variant type
• T*,size_t where T is convertible to variant type
• std::map<Variant,Variant>
• std::map where K and V is convertible to variant type

Construct aVariant containing the given string value (makes a copy).

TheVariant constructed will be of type MutableString, andis_string() will return true.

Construct aVariant containing the given std::vector ofVariant.

TheVariant constructed will be of type Vector.

Construct aVariant containing the given std::vector of something that can be constructed into aVariant.

TheVariant constructed will be of type Vector.

Construct aVariant from an array of supported types into a Vector.

TheVariant constructed will be of type Vector.

Construct a Variatn containing the given std::map ofVariant toVariant.

TheVariant constructed will be of type Map.

Construct aVariant containing the given std::map of something that can be constructed into aVariant, to something that can be constructed into aVariant.

TheVariant constructed will be of type Map.

Copy constructor.

Performs a deep copy.

Move constructor.

Efficiently moves the more complex data types by simply reassigning pointer ownership.

Get the pointer to the binary data contained in a blob.

This method works with both static and mutable blob.

Get the size of a blob.

This method works with both static and mutable blobs.

Const accessor for aVariant containing a bool.

Note: If theVariant is not of Bool type, this will assert.

Const accessor for aVariant containing a double.

Note: If theVariant is not of Double type, this will assert.

Const accessor for aVariant containing an integer.

Note: If theVariant is not of Int64 type, this will assert.

Get whether thisVariant contains a blob.

Note: No matter which type of blob theVariant contains, you can read its data viablob_data() and get its size viablob_size().

Get whether thisVariant contains a bool.

Get whether thisVariant contains a container type: Vector or Map.

Get whether thisVariant contains a double.

Get whether thisVariant contains a fundamental type: Null, Int64, Double, Bool, or one of the two String types.

Essentially !is_containerType().

Get whether thisVariant contains an integer.

Get whether thisVariant contains a map.

Get whether thisVariant contains a mutable blob.

Get whether thisVariant contains a mutable string.

Get whether thisVariant is currently null.

Get whether thisVariant contains a numeric type, Int64 or Double.

Get whether thisVariant contains a static blob.

Get whether thisVariant contains a static string.

Get whether thisVariant contains a string.

Note: No matter which type of string theVariant contains, you can read its value viastring_value().

Get whether thisVariant contains a vector.

Mutable accessor for aVariant containing a map ofVariant data.

Note: If theVariant is not of Map type, this will assert.

Const accessor for aVariant containing a map of strings toVariant data.

Note: If theVariant is not of Map type, this will assert.

Get a mutable pointer to the binary data contained in a blob.

If theVariant contains a static blob, it will be converted into a mutable blob, which copies the binary data into theVariant's buffer.

Const accessor for aVariant contianing mutable blob data.

Note: Unlike the non-const accessor, this accessor cannot "promote" a static blob to mutable, and thus will assert if theVariant you pass in is not of MutableBlob type.

Mutable accessor for aVariant containing a string.

If theVariant contains a static string, it will be converted into a mutable string, which copies the const char*'s data into a std::string.

Note: If theVariant is not one of the two String types, this will assert.

Const accessor for aVariant containing a string.

Note: Unlike the non-const accessor, this accessor cannot "promote" a static string to mutable, and thus returns a std::string copy instead of a const reference to a std::string

Inequality operator: x != y is evaluated as !(x == y).

Inequality operator, only meant for internal use.

Explanation: In order to useVariant as a key for std::map, we must provide a comparison function. This comparison function is ONLY for std::map to be able to use aVariant as a map key.

We define v1< v2 IFF:

• If different types, compare type as int: v1.type()< v2.type() (note: this means that Variant(1)<Variant(0.0) - be careful!)
• If both are int64: v1.int64_value()< v2.int64_value();
• If both are double: v1.double_value()< v2.double_value()
• If both are bool: v1.bool_value()< v2.bool_value();
• If both are either static or mutable strings: strcmp(v1, v2)< 0
• If both are vectors:
  • If v1[0]< v2[0], that means v1< v2 == true. Otherwise:
  • If v1[0] > v2[0], that means v1< v2 == false. Otherwise:
  • Continue to the next element of both vectors and compare again.
  • If you reach the end of one vector first, that vector is considered to be lesser.
• If both are maps, iterate similar to vectors (since maps are ordered), but for each element, first compare the key, then the value.
• If both are blobs, the smaller-sized blob is considered lesser. If both blobs are the same size, use memcmp to compare the bytes.

We have defined this operation such that if !(v1< v2) && !(v2< v1), it must follow that v1 == v2.

Note: This will not give you the results you expect if you compare Variants of different types! For example,Variant(0.0)< Variant(1).

Inequality operator: x<= y is evaluated as !(x > y)

Copy assignment operator.

Performs a deep copy.

Move assignment operator.

Efficiently moves the more complex data types by simply reassigning pointer ownership.

Equality operator.

Both the type and the value must be equal (except that static strings CAN be == to mutable strings). For container types, element-by-element comparison is performed. For strings, string comparison is performed.

Inequality operator: x > y is evaluated as y< x.

Inequality operator: x >= y is evaluated as !(x< y)

Sets theVariant to the given boolean value.

TheVariant's type will be set to Bool.

Sets theVariant to an double-precision floating point value.

TheVariant's type will be set to Double.

Sets theVariant to an 64-bit integer value.

TheVariant's type will be set to Int64.

Sets theVariant to a copy of the given map.

TheVariant's type will be set to Map.

Sets theVariant to a copy of the given binary data.

TheVariant's type will be set to MutableBlob.

Sets theVariant to a copy of the given string.

TheVariant's type will be set to SmallString if the size of the string is less than kMaxSmallStringSize (8 bytes on x86, 16 bytes on x64) or otherwise set to MutableString.

Sets theVariant value to null.

TheVariant's type will be Null.

Sets theVariant to point to static binary data.

TheVariant's type will be set to kTypeStaticBlob.

Note: If you use this method, you must ensure that the memory pointer to stays valid for the life of theVariant, or otherwise callmutable_blob_data() orset_mutable_blob(), which will copy the data into an internal buffer.

Sets theVariant to point to a static string buffer.

TheVariant's type will be set to StaticString.

Note: If you use this method, you must ensure that the memory pointed to stays valid for the life of theVariant, or otherwise callmutable_string() orset_mutable_string(), which will copy the string to an internal buffer.

Sets theVariant to a mutable string.

TheVariant's type will be set to MutableString.

Sets theVariant to a mutable string.

TheVariant's type will be set to MutableString.

Sets theVariant to a copy of the given vector.

TheVariant's type will be set to Vector.

Const accessor for aVariant containing a string.

This can return both static and mutable strings. The pointer is only guaranteed to persist if thisVariant's type is StaticString.

Note: If theVariant is not of StaticString or MutableString type, this will assert.

Get the current type contained in thisVariant.

Mutable accessor for aVariant containing a vector ofVariant data.

Note: If theVariant is not of Vector type, this will assert.

Const accessor for aVariant containing a vector ofVariant data.

Note: If theVariant is not of Vector type, this will assert.

Destructor. Frees the memory that thisVariant owns.

Get aVariant containing an empty map.

You can immediately callmap() on it to work with the map it contains.

Return aVariant containing an empty mutable blob of the requested size, filled with 0-bytes.

Get aVariant containing an empty mutable string.

Get an empty string variant.

Get aVariant containing an empty vector.

You can immediately callvector() on it to work with the vector it contains.

Get aVariant of bool value false.

Return aVariant from a boolean.

Return aVariant from a double-precision floating point number.

Return aVariant from a 64-bit integer.

Return aVariant containing a copy of binary data.

Return aVariant from a string.

This method makes a copy of the string.

Return aVariant that points to static binary data.

Note: If you use this function, you must ensure that the memory pointed to stays valid for the life of theVariant, otherwise call mutable_blob() orset_mutable_blob(), which will copy the data to an internal buffer.

Return aVariant from a static string.

Note: If you use this function, you must ensure that the memory pointed to stays valid for the life of theVariant, otherwise callmutable_string() orset_mutable_string(), which will copy the string to an internal buffer.

Return aVariant from a string, but make it mutable.

Only copies the string once, unlike Variant(std::string(value)), which copies the string twice.

Get aVariant of type Null.

Get aVariant of integer value 1.

Get aVariant of double value 1.0.

Get aVariant of bool value true.

Get the human-readable type name of aVariant type.

Get aVariant of integer value 0.

Get aVariant of double value 0.0.