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
|
#pragma once
#include <mbgl/util/peer.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/style/conversion.hpp>
#include <cassert>
#include <memory>
#include <string>
#include <stdexcept>
namespace mbgl {
namespace style {
class LayerObserver;
class Filter;
/**
* @brief Holds static data for a certain layer type.
*/
struct LayerTypeInfo {
/**
* @brief contains the layer type as defined in the style specification;
*/
const char* type;
/**
* @brief contains \c Source::Required if the corresponding layer type
* requires source. Contains \c Source::NotRequired otherwise.
*/
const enum class Source { Required, NotRequired } source;
/**
* @brief contains \c Pass3D::Required if the corresponding layer type
* requires 3D rendering pass. Contains \c Pass3D::NotRequired otherwise.
*/
const enum class Pass3D { Required, NotRequired } pass3d;
/**
* @brief contains \c Layout::Required if the corresponding layer type
* requires layouting. * contains \c Layout::NotRequired otherwise.
*/
const enum class Layout { Required, NotRequired } layout;
/**
* @brief contains \c Clipping::Required if the corresponding layer type
* requires clipping. Contains \c Clipping::NotRequired otherwise.
*/
const enum class Clipping { Required, NotRequired } clipping;
};
/**
* The runtime representation of a [layer](https://www.mapbox.com/mapbox-gl-style-spec/#layers) from the Mapbox Style
* Specification.
*
* `Layer` is an abstract base class; concrete derived classes are provided for each layer type. `Layer` contains
* functionality that is common to all layer types:
*
* * Runtime type information: type predicates and casting
* * Accessors for properties common to all layer types: ID, visibility, etc.
* * Cloning and copying
*
* All other functionality lives in the derived classes. To instantiate a layer, create an instance of the desired
* type, calling `LayerManager`:
*
* auto circleLayer = LayerManager::get()->createLayer("circle", ...);
*/
class Layer {
public:
Layer(const Layer& ) = delete;
Layer& operator=(const Layer&) = delete;
virtual ~Layer();
std::string getID() const;
// Source
std::string getSourceID() const;
std::string getSourceLayer() const;
void setSourceLayer(const std::string& sourceLayer);
// Filter
const Filter& getFilter() const;
void setFilter(const Filter&);
// Visibility
VisibilityType getVisibility() const;
void setVisibility(VisibilityType);
// Zoom range
float getMinZoom() const;
float getMaxZoom() const;
void setMinZoom(float);
void setMaxZoom(float);
// Dynamic properties
virtual optional<conversion::Error> setLayoutProperty(const std::string& name, const conversion::Convertible& value) = 0;
virtual optional<conversion::Error> setPaintProperty(const std::string& name, const conversion::Convertible& value) = 0;
optional<conversion::Error> setVisibility(const conversion::Convertible& value);
// Private implementation
// TODO : We should not have public mutable data members.
class Impl;
Immutable<Impl> baseImpl;
// Create a layer, copying all properties except id and paint properties from this layer.
virtual std::unique_ptr<Layer> cloneRef(const std::string& id) const = 0;
void setObserver(LayerObserver*);
// 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.
util::peer peer;
Layer(Immutable<Impl>);
const LayerTypeInfo* getTypeInfo() const noexcept;
protected:
virtual Mutable<Impl> mutableBaseImpl() const = 0;
LayerObserver* observer;
};
} // namespace style
} // namespace mbgl
|