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
|
#include <mbgl/style/sources/tileset_source.hpp>
#include <mbgl/style/conversion/tileset.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/constants.hpp>
#include <mbgl/util/enum.hpp>
namespace mbgl {
using TilesetScheme = Tileset::Scheme;
MBGL_DEFINE_ENUM(TilesetScheme, {{TilesetScheme::XYZ, "xyz"}, {TilesetScheme::TMS, "tms"}});
namespace style {
TilesetSource::TilesetSource(Immutable<Impl> impl_, variant<std::string, Tileset> urlOrTileset_)
: Source(std::move(impl_)), urlOrTileset(std::move(urlOrTileset_)) {}
TilesetSource::~TilesetSource() = default;
const Tileset* TilesetSource::getTileset() const {
if (urlOrTileset.is<Tileset>()) {
return &urlOrTileset.get<Tileset>();
}
return nullptr;
}
optional<std::string> TilesetSource::getURL() const {
if (urlOrTileset.is<Tileset>()) return nullopt;
return urlOrTileset.get<std::string>();
}
optional<Resource> TilesetSource::getResource() const {
if (urlOrTileset.is<std::string>()) {
return Resource::source(urlOrTileset.get<std::string>());
}
return nullopt;
}
namespace {
void serializeTileSet(Value& value, const mbgl::Tileset& tileset) {
assert(value.getObject());
using namespace conversion;
PropertyMap* properties = value.getObject();
properties->insert({"tiles", makeValue(tileset.tiles)});
properties->insert({"minzoom", tileset.zoomRange.min});
properties->insert({"maxzoom", tileset.zoomRange.max});
properties->insert({"scheme", makeValue(tileset.scheme)});
properties->insert({"bounds", makeValue(tileset.bounds)});
}
} // namespace
Value TilesetSource::serialize() const {
auto result = Source::serialize();
assert(result.getObject());
urlOrTileset.match(
[&](const std::string& url) {
result.getObject()->insert({"url", url});
},
[&](const mbgl::Tileset& tileset) { serializeTileSet(result, tileset); });
return result;
}
Value TilesetSource::getPropertyInternal(const std::string& name) const {
using namespace conversion;
if (auto* tileset = getTileset()) {
if (name == "tiles") return makeValue(tileset->tiles);
if (name == "minzoom") return tileset->zoomRange.min;
if (name == "maxzoom") return tileset->zoomRange.max;
if (name == "scheme") return makeValue(tileset->scheme);
if (name == "bounds") return makeValue(tileset->bounds);
} else if (auto url = getURL()) {
if (name == "url") return makeValue(*url);
}
return Value();
}
// static
Value TilesetSource::getPropertyDefaultValue(const std::string& name) {
using namespace conversion;
if (name == "scheme") return makeValue(TilesetScheme::XYZ);
if (name == "minzoom") return 0u;
if (name == "maxzoom") return util::DEFAULT_MAX_ZOOM;
return Source::getPropertyDefaultValue(name);
}
} // namespace style
} // namespace mbgl
|
