conversion_impl.hpp

Go to the documentation of this file.

#pragma once
 
#include <mbgl/style/color_ramp_property_value.hpp>
#include <mbgl/style/conversion.hpp>
#include <mbgl/style/expression/image.hpp>
#include <mbgl/style/layer.hpp>
#include <mbgl/style/property_value.hpp>
#include <mbgl/style/rotation.hpp>
#include <mbgl/style/transition_options.hpp>
#include <mbgl/util/feature.hpp>
#include <mbgl/util/geojson.hpp>
#include <mbgl/util/traits.hpp>
 
#include <mapbox/compatibility/value.hpp>
 
#include <array>
#include <chrono>
#include <string>
#include <type_traits>
#include <optional>
 
namespace mbgl {
namespace style {
 
namespace conversion {
 
template <typename T>
class ConversionTraits;
 
class Convertible {
public:
    template <typename T>
    // NOLINTNEXTLINE(bugprone-forwarding-reference-overload)
    Convertible(T&& value) : vtable(vtableForType<std::decay_t<T>>()) {
        static_assert(sizeof(Storage) >= sizeof(std::decay_t<T>), "Storage must be large enough to hold value type");
        new (static_cast<void*>(&storage)) std::decay_t<T>(std::forward<T>(value));
    }
 
    Convertible(Convertible&& v) noexcept : vtable(v.vtable) {
        // NOLINTNEXTLINE(performance-move-const-arg)
        vtable->move(std::move(v.storage), storage);
    }
 
    ~Convertible() {
        vtable->destroy(storage);
    }
 
    Convertible& operator=(Convertible&& v) noexcept {
        if (this != &v) {
            vtable->destroy(storage);
            vtable = v.vtable;
            // NOLINTNEXTLINE(performance-move-const-arg)
            vtable->move(std::move(v.storage), storage);
        }
        return *this;
    }
 
    Convertible()                              = delete;
    Convertible(const Convertible&)            = delete;
    Convertible& operator=(const Convertible&) = delete;
 
    friend inline bool isUndefined(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->isUndefined(v.storage);
    }
 
    friend inline bool isArray(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->isArray(v.storage);
    }
 
    friend inline std::size_t arrayLength(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->arrayLength(v.storage);
    }
 
    friend inline Convertible arrayMember(const Convertible& v, std::size_t i) {
        assert(v.vtable);
        return v.vtable->arrayMember(v.storage, i);
    }
 
    friend inline bool isObject(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->isObject(v.storage);
    }
 
    friend inline std::optional<Convertible> objectMember(const Convertible& v, const char * name) {
        assert(v.vtable);
        return v.vtable->objectMember(v.storage, name);
    }
 
    friend inline std::optional<Error> eachMember(const Convertible& v, const std::function<std::optional<Error> (const std::string&, const Convertible&)>& fn) {
        assert(v.vtable);
        return v.vtable->eachMember(v.storage, fn);
    }
 
    friend inline std::optional<bool> toBool(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->toBool(v.storage);
    }
 
    friend inline std::optional<float> toNumber(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->toNumber(v.storage);
    }
 
    friend inline std::optional<double> toDouble(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->toDouble(v.storage);
    }
 
    friend inline std::optional<std::string> toString(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->toString(v.storage);
    }
 
    friend inline std::optional<Value> toValue(const Convertible& v) {
        assert(v.vtable);
        return v.vtable->toValue(v.storage);
    }
 
    friend inline std::optional<GeoJSON> toGeoJSON(const Convertible& v, Error& error) {
        assert(v.vtable);
        return v.vtable->toGeoJSON(v.storage, error);
    }
 
private:
#if __ANDROID__
    // Android:     JSValue* or mbgl::android::Value
    using Storage = std::aligned_storage_t<32, 8>;
#elif __QT__
    // Qt:          JSValue* or QVariant
    using Storage = std::aligned_storage_t<32, 8>;
#else
    // Node:        JSValue* or v8::Local<v8::Value>
    // iOS/macOS:   JSValue* or id
    using Storage = std::aligned_storage_t<8, 8>;
#endif
 
    struct VTable {
        void (*move) (Storage&& src, Storage& dest);
        void (*destroy) (Storage&);
 
        bool (*isUndefined) (const Storage&);
 
        bool        (*isArray)     (const Storage&);
        std::size_t (*arrayLength) (const Storage&);
        Convertible (*arrayMember) (const Storage&, std::size_t);
 
        bool                  (*isObject)     (const Storage&);
        std::optional<Convertible> (*objectMember) (const Storage&, const char *);
        std::optional<Error>       (*eachMember)   (const Storage&, const std::function<std::optional<Error> (const std::string&, const Convertible&)>&);
 
        std::optional<bool>        (*toBool)   (const Storage&);
        std::optional<float>       (*toNumber) (const Storage&);
        std::optional<double>      (*toDouble) (const Storage&);
        std::optional<std::string> (*toString) (const Storage&);
        std::optional<Value>       (*toValue)  (const Storage&);
 
        // https://github.com/mapbox/mapbox-gl-native/issues/5623
        std::optional<GeoJSON> (*toGeoJSON) (const Storage&, Error&);
    };
 
    // Extracted this function from the table below to work around a GCC bug with differing
    // visibility settings for capturing lambdas: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80947
    template <typename T>
    static auto vtableEachMember(const Storage& s, const std::function<std::optional<Error>(const std::string&, const Convertible&)>& fn) {
        return ConversionTraits<T>::eachMember(reinterpret_cast<const T&>(s), [&](const std::string& k, T&& v) {
            return fn(k, Convertible(std::move(v)));
        });
    }
 
    template <typename T>
    static VTable* vtableForType() {
        using Traits = ConversionTraits<T>;
        static VTable vtable = {
            [] (Storage&& src, Storage& dest) {
                new (static_cast<void*>(&dest)) T(reinterpret_cast<T&&>(src));
            },
            [] (Storage& s) {
                reinterpret_cast<T&>(s).~T();
            },
            [] (const Storage& s) {
                return Traits::isUndefined(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s) {
                return Traits::isArray(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s) {
                return Traits::arrayLength(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s, std::size_t i) {
                return Convertible(Traits::arrayMember(reinterpret_cast<const T&>(s), i));
            },
            [] (const Storage& s) {
                return Traits::isObject(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s, const char * key) {
                std::optional<T> member = Traits::objectMember(reinterpret_cast<const T&>(s), key);
                if (member) {
                    return std::optional<Convertible>(Convertible(std::move(*member)));
                } else {
                    return std::optional<Convertible>();
                }
            },
            vtableEachMember<T>,
            [] (const Storage& s) {
                return Traits::toBool(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s) {
                return Traits::toNumber(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s) {
                return Traits::toDouble(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s) {
                return Traits::toString(reinterpret_cast<const T&>(s));
            },
            []  (const Storage& s) {
                return Traits::toValue(reinterpret_cast<const T&>(s));
            },
            [] (const Storage& s, Error& err) {
                return Traits::toGeoJSON(reinterpret_cast<const T&>(s), err);
            }
        };
        return &vtable;
    }
 
    VTable* vtable;
    Storage storage;
};
 
template <class T, class...Args>
std::optional<T> convert(const Convertible& value, Error& error, Args&&...args) {
    return Converter<T>()(value, error, std::forward<Args>(args)...);
}
 
template <>
struct ValueFactory<ColorRampPropertyValue> {
    static Value make(const ColorRampPropertyValue& value) { return value.getExpression().serialize(); }
};
 
template <>
struct ValueFactory<TransitionOptions> {
    static Value make(const TransitionOptions& value) { return value.serialize(); }
};
 
template <>
struct ValueFactory<Color> {
    static Value make(const Color& color) { return color.serialize(); }
};
 
template <typename T>
struct ValueFactory<T, typename std::enable_if_t<(!std::is_enum_v<T> && !is_linear_container<T>::value)>> {
    static Value make(const T& arg) { return {arg}; }
};
 
template <typename T>
struct ValueFactory<T, typename std::enable_if_t<std::is_enum_v<T>>> {
    static Value make(T arg) { return {Enum<T>::toString(arg)}; }
};
 
template <typename T>
struct ValueFactory<T, typename std::enable_if_t<is_linear_container<T>::value>> {
    static Value make(const T& arg) {
        mapbox::base::ValueArray result;
        result.reserve(arg.size());
        for (const auto& item : arg) {
            result.emplace_back(ValueFactory<std::decay_t<decltype(item)>>::make(item));
        }
        return result;
    }
};
 
template <>
struct ValueFactory<Position> {
    static Value make(const Position& position) {
        return ValueFactory<std::array<float, 3>>::make(position.getSpherical());
    }
};
 
template <>
struct ValueFactory<Rotation> {
    static Value make(const Rotation& rotation) { return {rotation.getAngle()}; }
};
 
template <>
struct ValueFactory<float> {
    static Value make(float f) { return f; }
};
 
template <typename T>
Value makeValue(T&& arg) {
    return ValueFactory<std::decay_t<T>>::make(std::forward<T>(arg));
}
 
template <typename T>
StyleProperty makeStyleProperty(const PropertyValue<T>& value) {
    return value.match([](const Undefined&) -> StyleProperty { return {}; },
                       [](const Color& c) -> StyleProperty {
                           return {makeValue(c), StyleProperty::Kind::Expression};
                       },
                       [](const PropertyExpression<T>& fn) -> StyleProperty {
                           return {fn.getExpression().serialize(), StyleProperty::Kind::Expression};
                       },
                       [](const auto& t) -> StyleProperty {
                           return {makeValue(t), StyleProperty::Kind::Constant};
                       });
}
 
inline StyleProperty makeStyleProperty(const TransitionOptions& value) {
    if (!value.isDefined()) return {};
    return {makeValue(value), StyleProperty::Kind::Transition};
}
 
inline StyleProperty makeStyleProperty(const ColorRampPropertyValue& value) {
    if (value.isUndefined()) return {};
    return {makeValue(value), StyleProperty::Kind::Expression};
}
 
} // namespace conversion
} // namespace style
} // namespace mbgl