[core] Convert style properties to a tuple-based approach

This converts the style property classes (CirclePaintProperties and so on) to the same tuple-based approach as gl::Attribute and gl::Uniform. The approach is outlined in https://github.com/mapbox/cpp/blob/master/C%2B%2B%20Structural%20Metaprogramming.md.

The main advantage of this approach is it allows writing algorithms that work on sets of style properties, without resorting to code generation or manually repetitive code. This lets us iterate on approaches to data-driven properties more easily.

Another advantage is that the cascading, unevaluated, and evaluated states of a set of properties exist as independent structures, instead of individual properties holding their own state. This is a more functional approach that makes data flow clearer and reduces state.

1 files changed, 244 insertions, 62 deletions

diff --git a/src/mbgl/style/layers/symbol_layer_properties.hpp b/src/mbgl/style/layers/symbol_layer_properties.hpp
index fefa0ae05e..8b72c4347a 100644
--- a/src/mbgl/style/layers/symbol_layer_properties.hpp
+++ b/src/mbgl/style/layers/symbol_layer_properties.hpp
@@ -9,69 +9,251 @@
 namespace mbgl {
 namespace style {
 
-class CascadeParameters;
-class CalculationParameters;
-
-class SymbolLayoutProperties {
-public:
-    void recalculate(const CalculationParameters&);
-
-    LayoutProperty<SymbolPlacementType> symbolPlacement { SymbolPlacementType::Point };
-    LayoutProperty<float> symbolSpacing { 250 };
-    LayoutProperty<bool> symbolAvoidEdges { false };
-    LayoutProperty<bool> iconAllowOverlap { false };
-    LayoutProperty<bool> iconIgnorePlacement { false };
-    LayoutProperty<bool> iconOptional { false };
-    LayoutProperty<AlignmentType> iconRotationAlignment { AlignmentType::Auto };
-    LayoutProperty<float> iconSize { 1 };
-    LayoutProperty<IconTextFitType> iconTextFit { IconTextFitType::None };
-    LayoutProperty<std::array<float, 4>> iconTextFitPadding { {{ 0, 0, 0, 0 }} };
-    LayoutProperty<std::string> iconImage { "" };
-    LayoutProperty<float> iconRotate { 0 };
-    LayoutProperty<float> iconPadding { 2 };
-    LayoutProperty<bool> iconKeepUpright { false };
-    LayoutProperty<std::array<float, 2>> iconOffset { {{ 0, 0 }} };
-    LayoutProperty<AlignmentType> textPitchAlignment { AlignmentType::Auto };
-    LayoutProperty<AlignmentType> textRotationAlignment { AlignmentType::Auto };
-    LayoutProperty<std::string> textField { "" };
-    LayoutProperty<std::vector<std::string>> textFont { { "Open Sans Regular", "Arial Unicode MS Regular" } };
-    LayoutProperty<float> textSize { 16 };
-    LayoutProperty<float> textMaxWidth { 10 };
-    LayoutProperty<float> textLineHeight { 1.2 };
-    LayoutProperty<float> textLetterSpacing { 0 };
-    LayoutProperty<TextJustifyType> textJustify { TextJustifyType::Center };
-    LayoutProperty<TextAnchorType> textAnchor { TextAnchorType::Center };
-    LayoutProperty<float> textMaxAngle { 45 };
-    LayoutProperty<float> textRotate { 0 };
-    LayoutProperty<float> textPadding { 2 };
-    LayoutProperty<bool> textKeepUpright { true };
-    LayoutProperty<TextTransformType> textTransform { TextTransformType::None };
-    LayoutProperty<std::array<float, 2>> textOffset { {{ 0, 0 }} };
-    LayoutProperty<bool> textAllowOverlap { false };
-    LayoutProperty<bool> textIgnorePlacement { false };
-    LayoutProperty<bool> textOptional { false };
-};
-
-class SymbolPaintProperties {
-public:
-    void cascade(const CascadeParameters&);
-    bool recalculate(const CalculationParameters&);
-
-    PaintProperty<float> iconOpacity { 1 };
-    PaintProperty<Color> iconColor { Color::black() };
-    PaintProperty<Color> iconHaloColor { {} };
-    PaintProperty<float> iconHaloWidth { 0 };
-    PaintProperty<float> iconHaloBlur { 0 };
-    PaintProperty<std::array<float, 2>> iconTranslate { {{ 0, 0 }} };
-    PaintProperty<TranslateAnchorType> iconTranslateAnchor { TranslateAnchorType::Map };
-    PaintProperty<float> textOpacity { 1 };
-    PaintProperty<Color> textColor { Color::black() };
-    PaintProperty<Color> textHaloColor { {} };
-    PaintProperty<float> textHaloWidth { 0 };
-    PaintProperty<float> textHaloBlur { 0 };
-    PaintProperty<std::array<float, 2>> textTranslate { {{ 0, 0 }} };
-    PaintProperty<TranslateAnchorType> textTranslateAnchor { TranslateAnchorType::Map };
+struct SymbolPlacement : LayoutProperty<SymbolPlacementType> {
+    static SymbolPlacementType defaultValue() { return SymbolPlacementType::Point; }
 };
 
+struct SymbolSpacing : LayoutProperty<float> {
+    static float defaultValue() { return 250; }
+};
+
+struct SymbolAvoidEdges : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct IconAllowOverlap : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct IconIgnorePlacement : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct IconOptional : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct IconRotationAlignment : LayoutProperty<AlignmentType> {
+    static AlignmentType defaultValue() { return AlignmentType::Auto; }
+};
+
+struct IconSize : LayoutProperty<float> {
+    static float defaultValue() { return 1; }
+};
+
+struct IconTextFit : LayoutProperty<IconTextFitType> {
+    static IconTextFitType defaultValue() { return IconTextFitType::None; }
+};
+
+struct IconTextFitPadding : LayoutProperty<std::array<float, 4>> {
+    static std::array<float, 4> defaultValue() { return {{ 0, 0, 0, 0 }}; }
+};
+
+struct IconImage : LayoutProperty<std::string> {
+    static std::string defaultValue() { return ""; }
+};
+
+struct IconRotate : LayoutProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct IconPadding : LayoutProperty<float> {
+    static float defaultValue() { return 2; }
+};
+
+struct IconKeepUpright : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct IconOffset : LayoutProperty<std::array<float, 2>> {
+    static std::array<float, 2> defaultValue() { return {{ 0, 0 }}; }
+};
+
+struct TextPitchAlignment : LayoutProperty<AlignmentType> {
+    static AlignmentType defaultValue() { return AlignmentType::Auto; }
+};
+
+struct TextRotationAlignment : LayoutProperty<AlignmentType> {
+    static AlignmentType defaultValue() { return AlignmentType::Auto; }
+};
+
+struct TextField : LayoutProperty<std::string> {
+    static std::string defaultValue() { return ""; }
+};
+
+struct TextFont : LayoutProperty<std::vector<std::string>> {
+    static std::vector<std::string> defaultValue() { return { "Open Sans Regular", "Arial Unicode MS Regular" }; }
+};
+
+struct TextSize : LayoutProperty<float> {
+    static float defaultValue() { return 16; }
+};
+
+struct TextMaxWidth : LayoutProperty<float> {
+    static float defaultValue() { return 10; }
+};
+
+struct TextLineHeight : LayoutProperty<float> {
+    static float defaultValue() { return 1.2; }
+};
+
+struct TextLetterSpacing : LayoutProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct TextJustify : LayoutProperty<TextJustifyType> {
+    static TextJustifyType defaultValue() { return TextJustifyType::Center; }
+};
+
+struct TextAnchor : LayoutProperty<TextAnchorType> {
+    static TextAnchorType defaultValue() { return TextAnchorType::Center; }
+};
+
+struct TextMaxAngle : LayoutProperty<float> {
+    static float defaultValue() { return 45; }
+};
+
+struct TextRotate : LayoutProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct TextPadding : LayoutProperty<float> {
+    static float defaultValue() { return 2; }
+};
+
+struct TextKeepUpright : LayoutProperty<bool> {
+    static bool defaultValue() { return true; }
+};
+
+struct TextTransform : LayoutProperty<TextTransformType> {
+    static TextTransformType defaultValue() { return TextTransformType::None; }
+};
+
+struct TextOffset : LayoutProperty<std::array<float, 2>> {
+    static std::array<float, 2> defaultValue() { return {{ 0, 0 }}; }
+};
+
+struct TextAllowOverlap : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct TextIgnorePlacement : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct TextOptional : LayoutProperty<bool> {
+    static bool defaultValue() { return false; }
+};
+
+struct IconOpacity : PaintProperty<float> {
+    static float defaultValue() { return 1; }
+};
+
+struct IconColor : PaintProperty<Color> {
+    static Color defaultValue() { return Color::black(); }
+};
+
+struct IconHaloColor : PaintProperty<Color> {
+    static Color defaultValue() { return {}; }
+};
+
+struct IconHaloWidth : PaintProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct IconHaloBlur : PaintProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct IconTranslate : PaintProperty<std::array<float, 2>> {
+    static std::array<float, 2> defaultValue() { return {{ 0, 0 }}; }
+};
+
+struct IconTranslateAnchor : PaintProperty<TranslateAnchorType> {
+    static TranslateAnchorType defaultValue() { return TranslateAnchorType::Map; }
+};
+
+struct TextOpacity : PaintProperty<float> {
+    static float defaultValue() { return 1; }
+};
+
+struct TextColor : PaintProperty<Color> {
+    static Color defaultValue() { return Color::black(); }
+};
+
+struct TextHaloColor : PaintProperty<Color> {
+    static Color defaultValue() { return {}; }
+};
+
+struct TextHaloWidth : PaintProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct TextHaloBlur : PaintProperty<float> {
+    static float defaultValue() { return 0; }
+};
+
+struct TextTranslate : PaintProperty<std::array<float, 2>> {
+    static std::array<float, 2> defaultValue() { return {{ 0, 0 }}; }
+};
+
+struct TextTranslateAnchor : PaintProperty<TranslateAnchorType> {
+    static TranslateAnchorType defaultValue() { return TranslateAnchorType::Map; }
+};
+
+class SymbolLayoutProperties : public LayoutProperties<
+    SymbolPlacement,
+    SymbolSpacing,
+    SymbolAvoidEdges,
+    IconAllowOverlap,
+    IconIgnorePlacement,
+    IconOptional,
+    IconRotationAlignment,
+    IconSize,
+    IconTextFit,
+    IconTextFitPadding,
+    IconImage,
+    IconRotate,
+    IconPadding,
+    IconKeepUpright,
+    IconOffset,
+    TextPitchAlignment,
+    TextRotationAlignment,
+    TextField,
+    TextFont,
+    TextSize,
+    TextMaxWidth,
+    TextLineHeight,
+    TextLetterSpacing,
+    TextJustify,
+    TextAnchor,
+    TextMaxAngle,
+    TextRotate,
+    TextPadding,
+    TextKeepUpright,
+    TextTransform,
+    TextOffset,
+    TextAllowOverlap,
+    TextIgnorePlacement,
+    TextOptional
+> {};
+
+class SymbolPaintProperties : public PaintProperties<
+    IconOpacity,
+    IconColor,
+    IconHaloColor,
+    IconHaloWidth,
+    IconHaloBlur,
+    IconTranslate,
+    IconTranslateAnchor,
+    TextOpacity,
+    TextColor,
+    TextHaloColor,
+    TextHaloWidth,
+    TextHaloBlur,
+    TextTranslate,
+    TextTranslateAnchor
+> {};
+
 } // namespace style
 } // namespace mbgl