layer.hpp

Go to the documentation of this file.

#pragma once
 
#include <mbgl/style/conversion.hpp>
#include <mbgl/style/style_property.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/util/immutable.hpp>
 
#include <mapbox/std/weak.hpp>
#include <mapbox/util/type_wrapper.hpp>
 
#include <cassert>
#include <memory>
#include <string>
#include <stdexcept>
#include <optional>
 
namespace mbgl {
namespace style {
 
class LayerObserver;
class Filter;
 
struct LayerTypeInfo {
    const char* type;
 
    const enum class Source { Required, NotRequired } source;
 
    const enum class Pass3D { Required, NotRequired } pass3d;
 
    const enum class Layout { Required, NotRequired } layout;
 
    const enum class FadingTiles { Required, NotRequired } fadingTiles;
 
    const enum class CrossTileIndex { Required, NotRequired } crossTileIndex;
 
    const enum class TileKind : uint8_t { Geometry, Raster, RasterDEM, NotRequired } tileKind;
};
 
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);
    void setSourceID(const std::string& sourceID);
 
    // 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
    std::optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value);
 
    virtual StyleProperty getProperty(const std::string&) const = 0;
    virtual Value serialize() const;
 
    // 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.
    mapbox::base::TypeWrapper peer;
    Layer(Immutable<Impl>);
 
    const LayerTypeInfo* getTypeInfo() const noexcept;
 
    mapbox::base::WeakPtr<Layer> makeWeakPtr() {
        return weakFactory.makeWeakPtr();
    }
 
protected:
    virtual Mutable<Impl> mutableBaseImpl() const = 0;
    void serializeProperty(Value&, const StyleProperty&, const char* propertyName, bool isPaint) const;
    virtual std::optional<conversion::Error> setPropertyInternal(const std::string& name,
                                                            const conversion::Convertible& value) = 0;
    LayerObserver* observer;
    mapbox::base::WeakPtrFactory<Layer> weakFactory {this};
 
private:
    std::optional<conversion::Error> setVisibility(const conversion::Convertible& value);
    std::optional<conversion::Error> setMinZoom(const conversion::Convertible& value);
    std::optional<conversion::Error> setMaxZoom(const conversion::Convertible& value);
};
 
} // namespace style
} // namespace mbgl