tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core][android] Introduce mbgl::style::LayerTypeInfo

Browse Source 
The `LayerTypeInfo` contains static meta data about certain layer type.

Each layer module should have a single immutable `LayerTypeInfo` instance
for the represented layer type. Both `LayerImpl` and `LayerFactory` from the
module always refer to the same `LayerTypeInfo` instance, so address of this
instance can be used as a layer module Id during the process life time.
This commit is contained in:
Mikhail Pozdnyakov
2018-11-15 15:47:25 +02:00
parent 73dcfe2d0d
commit 33818233cf
49 changed files with 256 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
platform/default/layer_manager.cpp
View File

@@ -2,6 +2,7 @@
#include <mbgl/style/layers/symbol_layer.hpp>
#include <mbgl/style/layers/background_layer.hpp>
#include <mbgl/style/layers/circle_layer.hpp>
#include <mbgl/style/layers/custom_layer.hpp>
#include <mbgl/style/layers/fill_extrusion_layer.hpp>
#include <mbgl/style/layers/fill_layer.hpp>
#include <mbgl/style/layers/heatmap_layer.hpp>
@@ -10,6 +11,7 @@
#include <mbgl/style/layers/raster_layer.hpp>
#include <mbgl/style/layers/symbol_layer.hpp>
#include <map>
#include <memory>
#include <vector>
@@ -19,36 +21,48 @@ namespace style {
class LayerManagerBase : public LayerManager {
public:
LayerManagerBase();
private:
void addLayerType(std::unique_ptr<LayerFactory>);
// LayerManager overrides.
std::unique_ptr<Layer> createLayer(const std::string& type, const std::string& id, const conversion::Convertible& value, conversion::Error& error) noexcept final;
std::vector<std::unique_ptr<LayerFactory>> factories;
std::map<std::string, LayerFactory*> typeToFactory;
};
LayerManagerBase::LayerManagerBase() {
factories.emplace_back(std::unique_ptr<LayerFactory>(new FillLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new LineLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new CircleLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new SymbolLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new RasterLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new BackgroundLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new HillshadeLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new FillExtrusionLayerFactory));
factories.emplace_back(std::unique_ptr<LayerFactory>(new HeatmapLayerFactory));
addLayerType(std::make_unique<FillLayerFactory>());
addLayerType(std::make_unique<LineLayerFactory>());
addLayerType(std::make_unique<CircleLayerFactory>());
addLayerType(std::make_unique<SymbolLayerFactory>());
addLayerType(std::make_unique<RasterLayerFactory>());
addLayerType(std::make_unique<BackgroundLayerFactory>());
addLayerType(std::make_unique<HillshadeLayerFactory>());
addLayerType(std::make_unique<FillExtrusionLayerFactory>());
addLayerType(std::make_unique<HeatmapLayerFactory>());
addLayerType(std::make_unique<CustomLayerFactory>());
}
void LayerManagerBase::addLayerType(std::unique_ptr<LayerFactory> factory) {
std::string type{factory->getTypeInfo()->type};
if (!type.empty()) {
typeToFactory.emplace(std::make_pair(std::move(type), factory.get()));
}
factories.emplace_back(std::move(factory));
}
std::unique_ptr<Layer> LayerManagerBase::createLayer(const std::string& type,
const std::string& id,
const conversion::Convertible& value,
conversion::Error& error) noexcept {
for (const auto& factory: factories) {
if (factory->supportsType(type)) {
auto layer = factory->createLayer(id, value);
if (!layer) {
error.message = "Error parsing a layer of type: " + type;
}
return layer;
auto search = typeToFactory.find(type);
if (search != typeToFactory.end()) {
auto layer = search->second->createLayer(id, value);
if (!layer) {
error.message = "Error parsing a layer of type: " + type;
}
return layer;
}
error.message = "Unsupported layer type: " + type;
return nullptr;