When you’re working with container types that can hold arrays, objects or values, it might be very beneficial if you could look inside to discover its structure and the value it holds. Using the API might be cumbersome, but luckily we can use the toJson() method to dump its content to the console, like so:

value.toJson()

mapbox::value is a type from the Mapbox GL Native library that can hold a variety of different data types (e.g. integers, strings, arrays, etc.). To introspect a mapbox::value object, you can use the following methods:

1. type() method: This method returns an enumeration value indicating the type of data stored in the mapbox::value object. For example, if the mapbox::value object holds an integer, the type() method will return mapbox::value_type::number_integer.
2. get_value_type() method: This method returns a string representation of the type stored in the mapbox::value object. For example, if the mapbox::value object holds a string, the get_value_type() method will return “string”.
3. get<T>() method: This method allows you to access the underlying value stored in the mapbox::value object. You need to specify the data type T that you expect to retrieve. If the type stored in the mapbox::value object is different from T, a mapbox::util::bad_cast exception will be thrown.
4. is<T>() method: This method allows you to check if the mapbox::value object holds a value of type T. It returns true if the underlying value is of type T, and false otherwise.

You can use these methods to introspect a mapbox::value object and determine its type and underlying value. Once you have determined the type and value of the mapbox::value object, you can use the appropriate methods to access and manipulate the value as needed.

Let’s dive a bit deeper into how you can leverage these methods.

Using type() to Determine Data Type

Consider a scenario where you have a mapbox::value object, but you’re not sure what type of data it holds. The type() method comes to the rescue. Here’s how you can use it:

mapbox::value myValue = …; // Your mapbox::value object
switch (myValue.type()) {
    case mapbox::value_type::number_integer:
        // Handle integer data
        break;
    case mapbox::value_type::string:
        // Handle string data
        break;
    case mapbox::value_type::array:
        // Handle array data
        break;
    // Add more cases for other data types as needed
}
By examining the result of type(), you can take appropriate actions based on the actual data type.

Getting the String Representation with get_value_type()

Sometimes, you might not need the specific enumeration value returned by type(). Instead, you might prefer a more human-readable representation of the data type. This is where get_value_type() shines:

mapbox::value myValue = …; // Your mapbox::value object

std::string valueType = myValue.get_value_type();

// Now, valueType contains a string representation of the data type.

This string can be helpful for logging, reporting, or simply for making your code more understandable.

Accessing the Underlying Value with get<T>()

To access the actual value contained within a mapbox::value object, you can use the get<T>() method. Specify the data type T that corresponds to the expected data type. If the mapbox::value object doesn’t hold a value of that type, an exception will be thrown. Here’s an example:

mapbox::value myValue = ...;  // Your mapbox::value object

try {
    int intValue = myValue.get<int>();  // Attempt to get an integer value
    // Handle intValue
} catch (const mapbox::util::bad_cast&) {
    // Handle the case where myValue doesn't contain an integer
}

This approach ensures type safety and helps prevent runtime errors caused by incompatible data types.

Checking the Type with is<T>()

Before attempting to access the value with get<T>(), you might want to check if the mapbox::value object actually holds a value of a specific type. This can be done using the is<T>() method:

mapbox::value myValue = ...;  // Your mapbox::value object

if (myValue.is<int>()) {
    // myValue contains an integer
    int intValue = myValue.get<int>();
} else {
    // Handle the case where myValue is not an integer
}

This approach allows you to safely access the value only if it matches the expected type.

Introspecting a mapbox::value object doesn’t have to be a daunting task. By using the type(), get_value_type(), get<T>(), and is<T>() methods, you can confidently explore the contents of these versatile objects. Whether you’re parsing JSON data, working with Mapbox GL Native, or dealing with any other scenario involving mapbox::value, these introspection techniques will be your reliable companions in understanding and handling your data. Happy coding!