[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, 130 insertions, 130 deletions

diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index d49e8d7fe3..61f360ff64 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -60,479 +60,479 @@ const Filter& SymbolLayer::getFilter() const {
 // Layout properties
 
 PropertyValue<SymbolPlacementType> SymbolLayer::getDefaultSymbolPlacement() {
-    return { SymbolPlacementType::Point };
+    return SymbolPlacement::defaultValue();
 }
 
 PropertyValue<SymbolPlacementType> SymbolLayer::getSymbolPlacement() const {
-    return impl->layout.symbolPlacement.get();
+    return impl->layout.unevaluated.get<SymbolPlacement>();
 }
 
 void SymbolLayer::setSymbolPlacement(PropertyValue<SymbolPlacementType> value) {
     if (value == getSymbolPlacement())
         return;
-    impl->layout.symbolPlacement.set(value);
+    impl->layout.unevaluated.get<SymbolPlacement>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "symbol-placement");
 }
 PropertyValue<float> SymbolLayer::getDefaultSymbolSpacing() {
-    return { 250 };
+    return SymbolSpacing::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getSymbolSpacing() const {
-    return impl->layout.symbolSpacing.get();
+    return impl->layout.unevaluated.get<SymbolSpacing>();
 }
 
 void SymbolLayer::setSymbolSpacing(PropertyValue<float> value) {
     if (value == getSymbolSpacing())
         return;
-    impl->layout.symbolSpacing.set(value);
+    impl->layout.unevaluated.get<SymbolSpacing>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "symbol-spacing");
 }
 PropertyValue<bool> SymbolLayer::getDefaultSymbolAvoidEdges() {
-    return { false };
+    return SymbolAvoidEdges::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getSymbolAvoidEdges() const {
-    return impl->layout.symbolAvoidEdges.get();
+    return impl->layout.unevaluated.get<SymbolAvoidEdges>();
 }
 
 void SymbolLayer::setSymbolAvoidEdges(PropertyValue<bool> value) {
     if (value == getSymbolAvoidEdges())
         return;
-    impl->layout.symbolAvoidEdges.set(value);
+    impl->layout.unevaluated.get<SymbolAvoidEdges>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "symbol-avoid-edges");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconAllowOverlap() {
-    return { false };
+    return IconAllowOverlap::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconAllowOverlap() const {
-    return impl->layout.iconAllowOverlap.get();
+    return impl->layout.unevaluated.get<IconAllowOverlap>();
 }
 
 void SymbolLayer::setIconAllowOverlap(PropertyValue<bool> value) {
     if (value == getIconAllowOverlap())
         return;
-    impl->layout.iconAllowOverlap.set(value);
+    impl->layout.unevaluated.get<IconAllowOverlap>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-allow-overlap");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconIgnorePlacement() {
-    return { false };
+    return IconIgnorePlacement::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconIgnorePlacement() const {
-    return impl->layout.iconIgnorePlacement.get();
+    return impl->layout.unevaluated.get<IconIgnorePlacement>();
 }
 
 void SymbolLayer::setIconIgnorePlacement(PropertyValue<bool> value) {
     if (value == getIconIgnorePlacement())
         return;
-    impl->layout.iconIgnorePlacement.set(value);
+    impl->layout.unevaluated.get<IconIgnorePlacement>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-ignore-placement");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconOptional() {
-    return { false };
+    return IconOptional::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconOptional() const {
-    return impl->layout.iconOptional.get();
+    return impl->layout.unevaluated.get<IconOptional>();
 }
 
 void SymbolLayer::setIconOptional(PropertyValue<bool> value) {
     if (value == getIconOptional())
         return;
-    impl->layout.iconOptional.set(value);
+    impl->layout.unevaluated.get<IconOptional>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-optional");
 }
 PropertyValue<AlignmentType> SymbolLayer::getDefaultIconRotationAlignment() {
-    return { AlignmentType::Auto };
+    return IconRotationAlignment::defaultValue();
 }
 
 PropertyValue<AlignmentType> SymbolLayer::getIconRotationAlignment() const {
-    return impl->layout.iconRotationAlignment.get();
+    return impl->layout.unevaluated.get<IconRotationAlignment>();
 }
 
 void SymbolLayer::setIconRotationAlignment(PropertyValue<AlignmentType> value) {
     if (value == getIconRotationAlignment())
         return;
-    impl->layout.iconRotationAlignment.set(value);
+    impl->layout.unevaluated.get<IconRotationAlignment>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-rotation-alignment");
 }
 PropertyValue<float> SymbolLayer::getDefaultIconSize() {
-    return { 1 };
+    return IconSize::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getIconSize() const {
-    return impl->layout.iconSize.get();
+    return impl->layout.unevaluated.get<IconSize>();
 }
 
 void SymbolLayer::setIconSize(PropertyValue<float> value) {
     if (value == getIconSize())
         return;
-    impl->layout.iconSize.set(value);
+    impl->layout.unevaluated.get<IconSize>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-size");
 }
 PropertyValue<IconTextFitType> SymbolLayer::getDefaultIconTextFit() {
-    return { IconTextFitType::None };
+    return IconTextFit::defaultValue();
 }
 
 PropertyValue<IconTextFitType> SymbolLayer::getIconTextFit() const {
-    return impl->layout.iconTextFit.get();
+    return impl->layout.unevaluated.get<IconTextFit>();
 }
 
 void SymbolLayer::setIconTextFit(PropertyValue<IconTextFitType> value) {
     if (value == getIconTextFit())
         return;
-    impl->layout.iconTextFit.set(value);
+    impl->layout.unevaluated.get<IconTextFit>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-text-fit");
 }
 PropertyValue<std::array<float, 4>> SymbolLayer::getDefaultIconTextFitPadding() {
-    return { {{ 0, 0, 0, 0 }} };
+    return IconTextFitPadding::defaultValue();
 }
 
 PropertyValue<std::array<float, 4>> SymbolLayer::getIconTextFitPadding() const {
-    return impl->layout.iconTextFitPadding.get();
+    return impl->layout.unevaluated.get<IconTextFitPadding>();
 }
 
 void SymbolLayer::setIconTextFitPadding(PropertyValue<std::array<float, 4>> value) {
     if (value == getIconTextFitPadding())
         return;
-    impl->layout.iconTextFitPadding.set(value);
+    impl->layout.unevaluated.get<IconTextFitPadding>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-text-fit-padding");
 }
 PropertyValue<std::string> SymbolLayer::getDefaultIconImage() {
-    return { "" };
+    return IconImage::defaultValue();
 }
 
 PropertyValue<std::string> SymbolLayer::getIconImage() const {
-    return impl->layout.iconImage.get();
+    return impl->layout.unevaluated.get<IconImage>();
 }
 
 void SymbolLayer::setIconImage(PropertyValue<std::string> value) {
     if (value == getIconImage())
         return;
-    impl->layout.iconImage.set(value);
+    impl->layout.unevaluated.get<IconImage>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-image");
 }
 PropertyValue<float> SymbolLayer::getDefaultIconRotate() {
-    return { 0 };
+    return IconRotate::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getIconRotate() const {
-    return impl->layout.iconRotate.get();
+    return impl->layout.unevaluated.get<IconRotate>();
 }
 
 void SymbolLayer::setIconRotate(PropertyValue<float> value) {
     if (value == getIconRotate())
         return;
-    impl->layout.iconRotate.set(value);
+    impl->layout.unevaluated.get<IconRotate>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-rotate");
 }
 PropertyValue<float> SymbolLayer::getDefaultIconPadding() {
-    return { 2 };
+    return IconPadding::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getIconPadding() const {
-    return impl->layout.iconPadding.get();
+    return impl->layout.unevaluated.get<IconPadding>();
 }
 
 void SymbolLayer::setIconPadding(PropertyValue<float> value) {
     if (value == getIconPadding())
         return;
-    impl->layout.iconPadding.set(value);
+    impl->layout.unevaluated.get<IconPadding>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-padding");
 }
 PropertyValue<bool> SymbolLayer::getDefaultIconKeepUpright() {
-    return { false };
+    return IconKeepUpright::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getIconKeepUpright() const {
-    return impl->layout.iconKeepUpright.get();
+    return impl->layout.unevaluated.get<IconKeepUpright>();
 }
 
 void SymbolLayer::setIconKeepUpright(PropertyValue<bool> value) {
     if (value == getIconKeepUpright())
         return;
-    impl->layout.iconKeepUpright.set(value);
+    impl->layout.unevaluated.get<IconKeepUpright>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-keep-upright");
 }
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconOffset() {
-    return { {{ 0, 0 }} };
+    return IconOffset::defaultValue();
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getIconOffset() const {
-    return impl->layout.iconOffset.get();
+    return impl->layout.unevaluated.get<IconOffset>();
 }
 
 void SymbolLayer::setIconOffset(PropertyValue<std::array<float, 2>> value) {
     if (value == getIconOffset())
         return;
-    impl->layout.iconOffset.set(value);
+    impl->layout.unevaluated.get<IconOffset>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "icon-offset");
 }
 PropertyValue<AlignmentType> SymbolLayer::getDefaultTextPitchAlignment() {
-    return { AlignmentType::Auto };
+    return TextPitchAlignment::defaultValue();
 }
 
 PropertyValue<AlignmentType> SymbolLayer::getTextPitchAlignment() const {
-    return impl->layout.textPitchAlignment.get();
+    return impl->layout.unevaluated.get<TextPitchAlignment>();
 }
 
 void SymbolLayer::setTextPitchAlignment(PropertyValue<AlignmentType> value) {
     if (value == getTextPitchAlignment())
         return;
-    impl->layout.textPitchAlignment.set(value);
+    impl->layout.unevaluated.get<TextPitchAlignment>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-pitch-alignment");
 }
 PropertyValue<AlignmentType> SymbolLayer::getDefaultTextRotationAlignment() {
-    return { AlignmentType::Auto };
+    return TextRotationAlignment::defaultValue();
 }
 
 PropertyValue<AlignmentType> SymbolLayer::getTextRotationAlignment() const {
-    return impl->layout.textRotationAlignment.get();
+    return impl->layout.unevaluated.get<TextRotationAlignment>();
 }
 
 void SymbolLayer::setTextRotationAlignment(PropertyValue<AlignmentType> value) {
     if (value == getTextRotationAlignment())
         return;
-    impl->layout.textRotationAlignment.set(value);
+    impl->layout.unevaluated.get<TextRotationAlignment>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-rotation-alignment");
 }
 PropertyValue<std::string> SymbolLayer::getDefaultTextField() {
-    return { "" };
+    return TextField::defaultValue();
 }
 
 PropertyValue<std::string> SymbolLayer::getTextField() const {
-    return impl->layout.textField.get();
+    return impl->layout.unevaluated.get<TextField>();
 }
 
 void SymbolLayer::setTextField(PropertyValue<std::string> value) {
     if (value == getTextField())
         return;
-    impl->layout.textField.set(value);
+    impl->layout.unevaluated.get<TextField>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-field");
 }
 PropertyValue<std::vector<std::string>> SymbolLayer::getDefaultTextFont() {
-    return { { "Open Sans Regular", "Arial Unicode MS Regular" } };
+    return TextFont::defaultValue();
 }
 
 PropertyValue<std::vector<std::string>> SymbolLayer::getTextFont() const {
-    return impl->layout.textFont.get();
+    return impl->layout.unevaluated.get<TextFont>();
 }
 
 void SymbolLayer::setTextFont(PropertyValue<std::vector<std::string>> value) {
     if (value == getTextFont())
         return;
-    impl->layout.textFont.set(value);
+    impl->layout.unevaluated.get<TextFont>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-font");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextSize() {
-    return { 16 };
+    return TextSize::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextSize() const {
-    return impl->layout.textSize.get();
+    return impl->layout.unevaluated.get<TextSize>();
 }
 
 void SymbolLayer::setTextSize(PropertyValue<float> value) {
     if (value == getTextSize())
         return;
-    impl->layout.textSize.set(value);
+    impl->layout.unevaluated.get<TextSize>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-size");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextMaxWidth() {
-    return { 10 };
+    return TextMaxWidth::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextMaxWidth() const {
-    return impl->layout.textMaxWidth.get();
+    return impl->layout.unevaluated.get<TextMaxWidth>();
 }
 
 void SymbolLayer::setTextMaxWidth(PropertyValue<float> value) {
     if (value == getTextMaxWidth())
         return;
-    impl->layout.textMaxWidth.set(value);
+    impl->layout.unevaluated.get<TextMaxWidth>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-max-width");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextLineHeight() {
-    return { 1.2 };
+    return TextLineHeight::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextLineHeight() const {
-    return impl->layout.textLineHeight.get();
+    return impl->layout.unevaluated.get<TextLineHeight>();
 }
 
 void SymbolLayer::setTextLineHeight(PropertyValue<float> value) {
     if (value == getTextLineHeight())
         return;
-    impl->layout.textLineHeight.set(value);
+    impl->layout.unevaluated.get<TextLineHeight>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-line-height");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextLetterSpacing() {
-    return { 0 };
+    return TextLetterSpacing::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextLetterSpacing() const {
-    return impl->layout.textLetterSpacing.get();
+    return impl->layout.unevaluated.get<TextLetterSpacing>();
 }
 
 void SymbolLayer::setTextLetterSpacing(PropertyValue<float> value) {
     if (value == getTextLetterSpacing())
         return;
-    impl->layout.textLetterSpacing.set(value);
+    impl->layout.unevaluated.get<TextLetterSpacing>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-letter-spacing");
 }
 PropertyValue<TextJustifyType> SymbolLayer::getDefaultTextJustify() {
-    return { TextJustifyType::Center };
+    return TextJustify::defaultValue();
 }
 
 PropertyValue<TextJustifyType> SymbolLayer::getTextJustify() const {
-    return impl->layout.textJustify.get();
+    return impl->layout.unevaluated.get<TextJustify>();
 }
 
 void SymbolLayer::setTextJustify(PropertyValue<TextJustifyType> value) {
     if (value == getTextJustify())
         return;
-    impl->layout.textJustify.set(value);
+    impl->layout.unevaluated.get<TextJustify>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-justify");
 }
 PropertyValue<TextAnchorType> SymbolLayer::getDefaultTextAnchor() {
-    return { TextAnchorType::Center };
+    return TextAnchor::defaultValue();
 }
 
 PropertyValue<TextAnchorType> SymbolLayer::getTextAnchor() const {
-    return impl->layout.textAnchor.get();
+    return impl->layout.unevaluated.get<TextAnchor>();
 }
 
 void SymbolLayer::setTextAnchor(PropertyValue<TextAnchorType> value) {
     if (value == getTextAnchor())
         return;
-    impl->layout.textAnchor.set(value);
+    impl->layout.unevaluated.get<TextAnchor>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-anchor");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextMaxAngle() {
-    return { 45 };
+    return TextMaxAngle::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextMaxAngle() const {
-    return impl->layout.textMaxAngle.get();
+    return impl->layout.unevaluated.get<TextMaxAngle>();
 }
 
 void SymbolLayer::setTextMaxAngle(PropertyValue<float> value) {
     if (value == getTextMaxAngle())
         return;
-    impl->layout.textMaxAngle.set(value);
+    impl->layout.unevaluated.get<TextMaxAngle>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-max-angle");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextRotate() {
-    return { 0 };
+    return TextRotate::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextRotate() const {
-    return impl->layout.textRotate.get();
+    return impl->layout.unevaluated.get<TextRotate>();
 }
 
 void SymbolLayer::setTextRotate(PropertyValue<float> value) {
     if (value == getTextRotate())
         return;
-    impl->layout.textRotate.set(value);
+    impl->layout.unevaluated.get<TextRotate>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-rotate");
 }
 PropertyValue<float> SymbolLayer::getDefaultTextPadding() {
-    return { 2 };
+    return TextPadding::defaultValue();
 }
 
 PropertyValue<float> SymbolLayer::getTextPadding() const {
-    return impl->layout.textPadding.get();
+    return impl->layout.unevaluated.get<TextPadding>();
 }
 
 void SymbolLayer::setTextPadding(PropertyValue<float> value) {
     if (value == getTextPadding())
         return;
-    impl->layout.textPadding.set(value);
+    impl->layout.unevaluated.get<TextPadding>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-padding");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextKeepUpright() {
-    return { true };
+    return TextKeepUpright::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextKeepUpright() const {
-    return impl->layout.textKeepUpright.get();
+    return impl->layout.unevaluated.get<TextKeepUpright>();
 }
 
 void SymbolLayer::setTextKeepUpright(PropertyValue<bool> value) {
     if (value == getTextKeepUpright())
         return;
-    impl->layout.textKeepUpright.set(value);
+    impl->layout.unevaluated.get<TextKeepUpright>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-keep-upright");
 }
 PropertyValue<TextTransformType> SymbolLayer::getDefaultTextTransform() {
-    return { TextTransformType::None };
+    return TextTransform::defaultValue();
 }
 
 PropertyValue<TextTransformType> SymbolLayer::getTextTransform() const {
-    return impl->layout.textTransform.get();
+    return impl->layout.unevaluated.get<TextTransform>();
 }
 
 void SymbolLayer::setTextTransform(PropertyValue<TextTransformType> value) {
     if (value == getTextTransform())
         return;
-    impl->layout.textTransform.set(value);
+    impl->layout.unevaluated.get<TextTransform>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-transform");
 }
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextOffset() {
-    return { {{ 0, 0 }} };
+    return TextOffset::defaultValue();
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getTextOffset() const {
-    return impl->layout.textOffset.get();
+    return impl->layout.unevaluated.get<TextOffset>();
 }
 
 void SymbolLayer::setTextOffset(PropertyValue<std::array<float, 2>> value) {
     if (value == getTextOffset())
         return;
-    impl->layout.textOffset.set(value);
+    impl->layout.unevaluated.get<TextOffset>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-offset");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextAllowOverlap() {
-    return { false };
+    return TextAllowOverlap::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextAllowOverlap() const {
-    return impl->layout.textAllowOverlap.get();
+    return impl->layout.unevaluated.get<TextAllowOverlap>();
 }
 
 void SymbolLayer::setTextAllowOverlap(PropertyValue<bool> value) {
     if (value == getTextAllowOverlap())
         return;
-    impl->layout.textAllowOverlap.set(value);
+    impl->layout.unevaluated.get<TextAllowOverlap>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-allow-overlap");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextIgnorePlacement() {
-    return { false };
+    return TextIgnorePlacement::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextIgnorePlacement() const {
-    return impl->layout.textIgnorePlacement.get();
+    return impl->layout.unevaluated.get<TextIgnorePlacement>();
 }
 
 void SymbolLayer::setTextIgnorePlacement(PropertyValue<bool> value) {
     if (value == getTextIgnorePlacement())
         return;
-    impl->layout.textIgnorePlacement.set(value);
+    impl->layout.unevaluated.get<TextIgnorePlacement>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-ignore-placement");
 }
 PropertyValue<bool> SymbolLayer::getDefaultTextOptional() {
-    return { false };
+    return TextOptional::defaultValue();
 }
 
 PropertyValue<bool> SymbolLayer::getTextOptional() const {
-    return impl->layout.textOptional.get();
+    return impl->layout.unevaluated.get<TextOptional>();
 }
 
 void SymbolLayer::setTextOptional(PropertyValue<bool> value) {
     if (value == getTextOptional())
         return;
-    impl->layout.textOptional.set(value);
+    impl->layout.unevaluated.get<TextOptional>() = value;
     impl->observer->onLayerLayoutPropertyChanged(*this, "text-optional");
 }
 
@@ -543,13 +543,13 @@ PropertyValue<float> SymbolLayer::getDefaultIconOpacity() {
 }
 
 PropertyValue<float> SymbolLayer::getIconOpacity(const optional<std::string>& klass) const {
-    return impl->paint.iconOpacity.get(klass);
+    return impl->paint.get<IconOpacity>(klass);
 }
 
 void SymbolLayer::setIconOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconOpacity(klass))
         return;
-    impl->paint.iconOpacity.set(value, klass);
+    impl->paint.set<IconOpacity>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -558,13 +558,13 @@ PropertyValue<Color> SymbolLayer::getDefaultIconColor() {
 }
 
 PropertyValue<Color> SymbolLayer::getIconColor(const optional<std::string>& klass) const {
-    return impl->paint.iconColor.get(klass);
+    return impl->paint.get<IconColor>(klass);
 }
 
 void SymbolLayer::setIconColor(PropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getIconColor(klass))
         return;
-    impl->paint.iconColor.set(value, klass);
+    impl->paint.set<IconColor>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -573,13 +573,13 @@ PropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
 }
 
 PropertyValue<Color> SymbolLayer::getIconHaloColor(const optional<std::string>& klass) const {
-    return impl->paint.iconHaloColor.get(klass);
+    return impl->paint.get<IconHaloColor>(klass);
 }
 
 void SymbolLayer::setIconHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getIconHaloColor(klass))
         return;
-    impl->paint.iconHaloColor.set(value, klass);
+    impl->paint.set<IconHaloColor>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -588,13 +588,13 @@ PropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
 }
 
 PropertyValue<float> SymbolLayer::getIconHaloWidth(const optional<std::string>& klass) const {
-    return impl->paint.iconHaloWidth.get(klass);
+    return impl->paint.get<IconHaloWidth>(klass);
 }
 
 void SymbolLayer::setIconHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconHaloWidth(klass))
         return;
-    impl->paint.iconHaloWidth.set(value, klass);
+    impl->paint.set<IconHaloWidth>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -603,13 +603,13 @@ PropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
 }
 
 PropertyValue<float> SymbolLayer::getIconHaloBlur(const optional<std::string>& klass) const {
-    return impl->paint.iconHaloBlur.get(klass);
+    return impl->paint.get<IconHaloBlur>(klass);
 }
 
 void SymbolLayer::setIconHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getIconHaloBlur(klass))
         return;
-    impl->paint.iconHaloBlur.set(value, klass);
+    impl->paint.set<IconHaloBlur>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -618,13 +618,13 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate(const optional<std::string>& klass) const {
-    return impl->paint.iconTranslate.get(klass);
+    return impl->paint.get<IconTranslate>(klass);
 }
 
 void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getIconTranslate(klass))
         return;
-    impl->paint.iconTranslate.set(value, klass);
+    impl->paint.set<IconTranslate>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -633,13 +633,13 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor()
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->paint.iconTranslateAnchor.get(klass);
+    return impl->paint.get<IconTranslateAnchor>(klass);
 }
 
 void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getIconTranslateAnchor(klass))
         return;
-    impl->paint.iconTranslateAnchor.set(value, klass);
+    impl->paint.set<IconTranslateAnchor>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -648,13 +648,13 @@ PropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
 }
 
 PropertyValue<float> SymbolLayer::getTextOpacity(const optional<std::string>& klass) const {
-    return impl->paint.textOpacity.get(klass);
+    return impl->paint.get<TextOpacity>(klass);
 }
 
 void SymbolLayer::setTextOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextOpacity(klass))
         return;
-    impl->paint.textOpacity.set(value, klass);
+    impl->paint.set<TextOpacity>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -663,13 +663,13 @@ PropertyValue<Color> SymbolLayer::getDefaultTextColor() {
 }
 
 PropertyValue<Color> SymbolLayer::getTextColor(const optional<std::string>& klass) const {
-    return impl->paint.textColor.get(klass);
+    return impl->paint.get<TextColor>(klass);
 }
 
 void SymbolLayer::setTextColor(PropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getTextColor(klass))
         return;
-    impl->paint.textColor.set(value, klass);
+    impl->paint.set<TextColor>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -678,13 +678,13 @@ PropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
 }
 
 PropertyValue<Color> SymbolLayer::getTextHaloColor(const optional<std::string>& klass) const {
-    return impl->paint.textHaloColor.get(klass);
+    return impl->paint.get<TextHaloColor>(klass);
 }
 
 void SymbolLayer::setTextHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
     if (value == getTextHaloColor(klass))
         return;
-    impl->paint.textHaloColor.set(value, klass);
+    impl->paint.set<TextHaloColor>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -693,13 +693,13 @@ PropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
 }
 
 PropertyValue<float> SymbolLayer::getTextHaloWidth(const optional<std::string>& klass) const {
-    return impl->paint.textHaloWidth.get(klass);
+    return impl->paint.get<TextHaloWidth>(klass);
 }
 
 void SymbolLayer::setTextHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextHaloWidth(klass))
         return;
-    impl->paint.textHaloWidth.set(value, klass);
+    impl->paint.set<TextHaloWidth>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -708,13 +708,13 @@ PropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
 }
 
 PropertyValue<float> SymbolLayer::getTextHaloBlur(const optional<std::string>& klass) const {
-    return impl->paint.textHaloBlur.get(klass);
+    return impl->paint.get<TextHaloBlur>(klass);
 }
 
 void SymbolLayer::setTextHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
     if (value == getTextHaloBlur(klass))
         return;
-    impl->paint.textHaloBlur.set(value, klass);
+    impl->paint.set<TextHaloBlur>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -723,13 +723,13 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
 }
 
 PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate(const optional<std::string>& klass) const {
-    return impl->paint.textTranslate.get(klass);
+    return impl->paint.get<TextTranslate>(klass);
 }
 
 void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
     if (value == getTextTranslate(klass))
         return;
-    impl->paint.textTranslate.set(value, klass);
+    impl->paint.set<TextTranslate>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }
 
@@ -738,13 +738,13 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor()
 }
 
 PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor(const optional<std::string>& klass) const {
-    return impl->paint.textTranslateAnchor.get(klass);
+    return impl->paint.get<TextTranslateAnchor>(klass);
 }
 
 void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
     if (value == getTextTranslateAnchor(klass))
         return;
-    impl->paint.textTranslateAnchor.set(value, klass);
+    impl->paint.set<TextTranslateAnchor>(value, klass);
     impl->observer->onLayerPaintPropertyChanged(*this);
 }