1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
#include <mbgl/style/expression/value.hpp>
namespace mbgl {
namespace style {
namespace expression {
struct ConvertValue {
// null_value_t, bool, uint64_t, int64_t, double, std::string,
// mapbox::util::recursive_wrapper<std::vector<value>>,
// mapbox::util::recursive_wrapper<std::unordered_map<std::string, value>>
Value operator()(const std::vector<mbgl::Value>& v) {
std::vector<Value> result;
for(const auto& item : v) {
result.emplace_back(convertValue(item));
}
return result;
}
Value operator()(const std::unordered_map<std::string, mbgl::Value>& v) {
std::unordered_map<std::string, Value> result;
for(const auto& entry : v) {
result.emplace(entry.first, convertValue(entry.second));
}
return result;
}
Value operator()(const std::string& s) { return s; }
Value operator()(const bool& b) { return b; }
Value operator()(const mbgl::NullValue) { return Null; }
template <typename T>
Value operator()(const T& v) { return *numericValue<float>(v); }
};
Value convertValue(const mbgl::Value& value) {
return mbgl::Value::visit(value, ConvertValue());
}
type::Type typeOf(const Value& value) {
return value.match(
[&](bool) -> type::Type { return type::Boolean; },
[&](float) -> type::Type { return type::Number; },
[&](const std::string&) -> type::Type { return type::String; },
[&](const mbgl::Color&) -> type::Type { return type::Color; },
[&](const NullValue&) -> type::Type { return type::Null; },
[&](const std::unordered_map<std::string, Value>&) -> type::Type { return type::Object; },
[&](const std::vector<Value>& arr) -> type::Type {
optional<type::Type> itemType;
for (const auto& item : arr) {
const auto& t = typeOf(item);
const auto& tname = type::toString(t);
if (!itemType) {
itemType = {t};
} else if (type::toString(*itemType) == tname) {
continue;
} else {
itemType = {type::Value};
break;
}
}
if (!itemType) { itemType = {type::Value}; }
return type::Array(*itemType, arr.size());
}
);
}
std::string stringify(const Value& value) {
return value.match(
[&] (const NullValue&) { return std::string("null"); },
[&] (bool b) { return std::string(b ? "true" : "false"); },
[&] (float f) { return ceilf(f) == f ? std::to_string((int)f) : std::to_string(f); },
[&] (const std::string& s) { return "\"" + s + "\""; },
[&] (const mbgl::Color& c) { return c.stringify(); },
[&] (const std::vector<Value>& arr) {
std::string result = "[";
for(const auto& item : arr) {
if (result.size() > 1) result += ",";
result += stringify(item);
}
return result + "]";
},
[&] (const std::unordered_map<std::string, Value>& obj) {
std::string result = "{";
for(const auto& entry : obj) {
if (result.size() > 1) result += ",";
result += stringify(entry.first) + ":" + stringify(entry.second);
}
return result + "}";
}
);
}
template <> type::Type valueTypeToExpressionType<Value>() { return type::Value; }
template <> type::Type valueTypeToExpressionType<NullValue>() { return type::Null; }
template <> type::Type valueTypeToExpressionType<bool>() { return type::Boolean; }
template <> type::Type valueTypeToExpressionType<float>() { return type::Number; }
template <> type::Type valueTypeToExpressionType<std::string>() { return type::String; }
template <> type::Type valueTypeToExpressionType<mbgl::Color>() { return type::Color; }
template <> type::Type valueTypeToExpressionType<std::unordered_map<std::string, Value>>() { return type::Object; }
template <> type::Type valueTypeToExpressionType<std::array<float, 2>>() { return type::Array(type::Number, 2); }
template <> type::Type valueTypeToExpressionType<std::array<float, 4>>() { return type::Array(type::Number, 4); }
template <> type::Type valueTypeToExpressionType<std::vector<Value>>() { return type::Array(type::Value); }
} // namespace expression
} // namespace style
} // namespace mbgl
|
