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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
#pragma once
#include <mapbox/std/weak.hpp>
#include <mapbox/util/type_wrapper.hpp>
#include <mbgl/storage/resource.hpp>
#include <mbgl/style/source_data.hpp>
#include <mbgl/style/source_parameters.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/tile/tile_kind.hpp>
#include <mbgl/util/chrono.hpp>
#include <mbgl/util/feature.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/variant.hpp>
#include <memory>
#include <string>
namespace mbgl {
class FileSource;
class Tileset;
namespace style {
class VectorSource;
class RasterSource;
class RasterDEMSource;
class GeoJSONSource;
class SourceObserver;
struct LayerTypeInfo;
/**
* @brief Holds static data for a certain source type.
*/
struct SourceTypeInfo {
/**
* @brief contains the source type as defined in the style specification;
*/
const char* type;
/**
* @brief specifies whether the source supports tile prefetching;
*/
const enum class TilePrefetch : bool { No, Yes } tilePrefetch;
/**
* @brief specifies whether the source operates with the loaded tile set;
*/
const enum class TileSet : bool { No, Yes } tileSet;
/**
* @brief specifies source's tile kind;
*/
const optional<TileKind> tileKind;
};
/**
* The runtime representation of a [source](https://www.mapbox.com/mapbox-gl-style-spec/#sources) from the Mapbox Style
* Specification.
*
* `Source` is an abstract base class; concrete derived classes are provided for each source type. `Source` contains
* functionality that is common to all layer types:
*
* * Runtime type information: type predicates and casting
* * Accessors for properties common to all source types: ID, etc.
* * Cloning and copying
*
* All other functionality lives in the derived classes. To instantiate a source, create an instance of the desired
* type, passing the ID:
*
* auto vectorSource = std::make_unique<VectorSource>("my-vector-source");
*/
class Source : public Serializable {
public:
Source(const Source&) = delete;
Source& operator=(const Source&) = delete;
virtual ~Source();
std::string getID() const;
optional<std::string> getAttribution() const;
// The data from the volatile sources are not stored in a persistent storage.
bool isVolatile() const noexcept;
void setVolatile(bool) noexcept;
// Private implementation
class Impl;
Immutable<Impl> baseImpl;
void setObserver(SourceObserver*);
SourceObserver* observer = nullptr;
virtual void loadDescription(FileSource&) = 0;
virtual void setSourceData(SourceData) {}
/**
* @brief Returns resource for loading, if required by this source; returns `nullopt` otherwise.
*
* If already loaded, this will return nullopt as well for Tiled sources (SourceTypeInfo::TileSet == Yes)
*
* @return optional<Resource>
*/
virtual optional<Resource> getResource() const { return nullopt; }
/**
* @brief for tiled sources (SourceTypeInfo::TileSet == Yes) this will return the TileSet when
* loaded, nullptr in any other case.
*
* @return Tileset* or nullptr
*/
virtual const Tileset* getTileset() const { return nullptr; }
/**
* @brief Returns the GeoJSON data, if this source supports GeoJSON format; returns `nullptr` otherwise.
*
* @return const GeoJSONData*
*/
virtual const GeoJSONData* getGeoJSONData() const { return nullptr; }
virtual void setSourceParameters(SourceParameters) {}
virtual void invalidateTile(const CanonicalTileID&) {}
virtual void invalidateRegion(const LatLngBounds&) {}
void setPrefetchZoomDelta(optional<uint8_t> delta) noexcept;
optional<uint8_t> getPrefetchZoomDelta() const noexcept;
int32_t getCoveringZoomLevel(double z) const noexcept;
uint16_t getTileSize() const;
// If the given source supports loading tiles from a server,
// sets the minimum tile update interval.
// Update network requests that are more frequent than the
// minimum tile update interval are suppressed.
//
// Default value is `Duration::zero()`.
void setMinimumTileUpdateInterval(Duration) noexcept;
Duration getMinimumTileUpdateInterval() const noexcept;
// Sets a limit for how much a parent tile can be overscaled.
//
// When a set of tiles for a current zoom level is being rendered and some of the
// ideal tiles that cover the screen are not yet loaded, parent tile could be
// used instead. This might introduce unwanted rendering side-effects, especially
// for raster tiles that are overscaled multiple times.
//
// For example, an overscale factor of 3 would mean that on zoom level 3, the
// minimum zoom level of a parent tile that could be used in place of an ideal
// tile during rendering would be zoom 0. By default, no limit is set, so any
// parent tile may be used.
void setMaxOverscaleFactorForParentTiles(optional<uint8_t> overscaleFactor) noexcept;
optional<uint8_t> getMaxOverscaleFactorForParentTiles() const noexcept;
void dumpDebugLogs() const;
virtual bool supportsLayerType(const mbgl::style::LayerTypeInfo*) const = 0;
bool loaded = false;
// For use in SDK bindings, which store a reference to a platform-native peer
// object here, so that separately-obtained references to this object share
// identical platform-native peers.
mapbox::base::TypeWrapper peer;
optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value);
Value getProperty(const std::string&) const;
virtual mapbox::base::WeakPtr<Source> makeWeakPtr() = 0;
const SourceTypeInfo* getTypeInfo() const noexcept;
Value serialize() const override;
protected:
explicit Source(Immutable<Impl>);
virtual Mutable<Impl> createMutable() const noexcept = 0;
virtual optional<conversion::Error> setPropertyInternal(const std::string& name,
const conversion::Convertible& value);
virtual Value getPropertyInternal(const std::string&) const;
};
} // namespace style
} // namespace mbgl
|
