[core] Optimize generated set{Paint,Layout}Property code

14 files changed, 2261 insertions, 1292 deletions

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index d35e2c66ca..e875f5b142 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -707,6 +707,7 @@ set(MBGL_CORE_FILES
     src/mbgl/util/dtoa.cpp
     src/mbgl/util/dtoa.hpp
     src/mbgl/util/event.cpp
+    src/mbgl/util/fnv_hash.hpp
     src/mbgl/util/font_stack.cpp
     src/mbgl/util/geo.cpp
     src/mbgl/util/geojson_impl.cpp
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index 837d557722..88e175cb7c 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -158,70 +159,115 @@ TransitionOptions BackgroundLayer::getBackgroundOpacityTransition() const {
 using namespace conversion;
 
 optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    enum class Property {
+        Unknown,
+        BackgroundColor,
+        BackgroundPattern,
+        BackgroundOpacity,
+        BackgroundColorTransition,
+        BackgroundPatternTransition,
+        BackgroundOpacityTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("background-color"):
+        if (name == "background-color") {
+            property = Property::BackgroundColor;
+        }
+        break;
+    case util::hashFNV1a("background-color-transition"):
+        if (name == "background-color-transition") {
+            property = Property::BackgroundColorTransition;
+        }
+        break;
+    case util::hashFNV1a("background-pattern"):
+        if (name == "background-pattern") {
+            property = Property::BackgroundPattern;
+        }
+        break;
+    case util::hashFNV1a("background-pattern-transition"):
+        if (name == "background-pattern-transition") {
+            property = Property::BackgroundPatternTransition;
+        }
+        break;
+    case util::hashFNV1a("background-opacity"):
+        if (name == "background-opacity") {
+            property = Property::BackgroundOpacity;
+        }
+        break;
+    case util::hashFNV1a("background-opacity-transition"):
+        if (name == "background-opacity-transition") {
+            property = Property::BackgroundOpacityTransition;
+        }
+        break;
     
-    if (name == "background-color") {
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::BackgroundColor) {
         Error error;
         optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setBackgroundColor(*typedValue);
         return nullopt;
-    }
-    if (name == "background-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setBackgroundColorTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "background-pattern") {
+    if (property == Property::BackgroundPattern) {
         Error error;
         optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setBackgroundPattern(*typedValue);
         return nullopt;
-    }
-    if (name == "background-pattern-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setBackgroundPatternTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "background-opacity") {
+    if (property == Property::BackgroundOpacity) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setBackgroundOpacity(*typedValue);
         return nullopt;
+        
     }
-    if (name == "background-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
+    
 
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    
+    if (property == Property::BackgroundColorTransition) {
+        setBackgroundColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::BackgroundPatternTransition) {
+        setBackgroundPatternTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::BackgroundOpacityTransition) {
         setBackgroundOpacityTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -242,7 +288,21 @@ optional<Error> BackgroundLayer::setLayoutProperty(const std::string& name, cons
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 3f769e935c..eb3227da37 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -402,238 +403,316 @@ TransitionOptions CircleLayer::getCircleStrokeOpacityTransition() const {
 using namespace conversion;
 
 optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    
-    if (name == "circle-radius") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    enum class Property {
+        Unknown,
+        CircleRadius,
+        CircleColor,
+        CircleBlur,
+        CircleOpacity,
+        CircleTranslate,
+        CircleTranslateAnchor,
+        CirclePitchScale,
+        CirclePitchAlignment,
+        CircleStrokeWidth,
+        CircleStrokeColor,
+        CircleStrokeOpacity,
+        CircleRadiusTransition,
+        CircleColorTransition,
+        CircleBlurTransition,
+        CircleOpacityTransition,
+        CircleTranslateTransition,
+        CircleTranslateAnchorTransition,
+        CirclePitchScaleTransition,
+        CirclePitchAlignmentTransition,
+        CircleStrokeWidthTransition,
+        CircleStrokeColorTransition,
+        CircleStrokeOpacityTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("circle-radius"):
+        if (name == "circle-radius") {
+            property = Property::CircleRadius;
         }
-
-        setCircleRadius(*typedValue);
-        return nullopt;
-    }
-    if (name == "circle-radius-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        break;
+    case util::hashFNV1a("circle-radius-transition"):
+        if (name == "circle-radius-transition") {
+            property = Property::CircleRadiusTransition;
         }
-
-        setCircleRadiusTransition(*transition);
-        return nullopt;
-    }
-    
-    if (name == "circle-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+        break;
+    case util::hashFNV1a("circle-color"):
+        if (name == "circle-color") {
+            property = Property::CircleColor;
         }
-
-        setCircleColor(*typedValue);
-        return nullopt;
-    }
-    if (name == "circle-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        break;
+    case util::hashFNV1a("circle-color-transition"):
+        if (name == "circle-color-transition") {
+            property = Property::CircleColorTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-blur"):
+        if (name == "circle-blur") {
+            property = Property::CircleBlur;
+        }
+        break;
+    case util::hashFNV1a("circle-blur-transition"):
+        if (name == "circle-blur-transition") {
+            property = Property::CircleBlurTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-opacity"):
+        if (name == "circle-opacity") {
+            property = Property::CircleOpacity;
+        }
+        break;
+    case util::hashFNV1a("circle-opacity-transition"):
+        if (name == "circle-opacity-transition") {
+            property = Property::CircleOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-translate"):
+        if (name == "circle-translate") {
+            property = Property::CircleTranslate;
+        }
+        break;
+    case util::hashFNV1a("circle-translate-transition"):
+        if (name == "circle-translate-transition") {
+            property = Property::CircleTranslateTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-translate-anchor"):
+        if (name == "circle-translate-anchor") {
+            property = Property::CircleTranslateAnchor;
+        }
+        break;
+    case util::hashFNV1a("circle-translate-anchor-transition"):
+        if (name == "circle-translate-anchor-transition") {
+            property = Property::CircleTranslateAnchorTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-pitch-scale"):
+        if (name == "circle-pitch-scale") {
+            property = Property::CirclePitchScale;
         }
+        break;
+    case util::hashFNV1a("circle-pitch-scale-transition"):
+        if (name == "circle-pitch-scale-transition") {
+            property = Property::CirclePitchScaleTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-pitch-alignment"):
+        if (name == "circle-pitch-alignment") {
+            property = Property::CirclePitchAlignment;
+        }
+        break;
+    case util::hashFNV1a("circle-pitch-alignment-transition"):
+        if (name == "circle-pitch-alignment-transition") {
+            property = Property::CirclePitchAlignmentTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-stroke-width"):
+        if (name == "circle-stroke-width") {
+            property = Property::CircleStrokeWidth;
+        }
+        break;
+    case util::hashFNV1a("circle-stroke-width-transition"):
+        if (name == "circle-stroke-width-transition") {
+            property = Property::CircleStrokeWidthTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-stroke-color"):
+        if (name == "circle-stroke-color") {
+            property = Property::CircleStrokeColor;
+        }
+        break;
+    case util::hashFNV1a("circle-stroke-color-transition"):
+        if (name == "circle-stroke-color-transition") {
+            property = Property::CircleStrokeColorTransition;
+        }
+        break;
+    case util::hashFNV1a("circle-stroke-opacity"):
+        if (name == "circle-stroke-opacity") {
+            property = Property::CircleStrokeOpacity;
+        }
+        break;
+    case util::hashFNV1a("circle-stroke-opacity-transition"):
+        if (name == "circle-stroke-opacity-transition") {
+            property = Property::CircleStrokeOpacityTransition;
+        }
+        break;
+    
+    }
 
-        setCircleColorTransition(*transition);
-        return nullopt;
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
     }
-    
-    if (name == "circle-blur") {
+
+        
+    if (property == Property::CircleRadius || property == Property::CircleBlur || property == Property::CircleOpacity || property == Property::CircleStrokeWidth || property == Property::CircleStrokeOpacity) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setCircleBlur(*typedValue);
-        return nullopt;
-    }
-    if (name == "circle-blur-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::CircleRadius) {
+            setCircleRadius(*typedValue);
+            return nullopt;
         }
-
-        setCircleBlurTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::CircleBlur) {
+            setCircleBlur(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::CircleOpacity) {
+            setCircleOpacity(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::CircleStrokeWidth) {
+            setCircleStrokeWidth(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::CircleStrokeOpacity) {
+            setCircleStrokeOpacity(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "circle-opacity") {
+    if (property == Property::CircleColor || property == Property::CircleStrokeColor) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setCircleOpacity(*typedValue);
-        return nullopt;
-    }
-    if (name == "circle-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::CircleColor) {
+            setCircleColor(*typedValue);
+            return nullopt;
         }
-
-        setCircleOpacityTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::CircleStrokeColor) {
+            setCircleStrokeColor(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "circle-translate") {
+    if (property == Property::CircleTranslate) {
         Error error;
         optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setCircleTranslate(*typedValue);
         return nullopt;
-    }
-    if (name == "circle-translate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setCircleTranslateTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "circle-translate-anchor") {
+    if (property == Property::CircleTranslateAnchor) {
         Error error;
         optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setCircleTranslateAnchor(*typedValue);
         return nullopt;
-    }
-    if (name == "circle-translate-anchor-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setCircleTranslateAnchorTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "circle-pitch-scale") {
+    if (property == Property::CirclePitchScale) {
         Error error;
         optional<PropertyValue<CirclePitchScaleType>> typedValue = convert<PropertyValue<CirclePitchScaleType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setCirclePitchScale(*typedValue);
         return nullopt;
-    }
-    if (name == "circle-pitch-scale-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setCirclePitchScaleTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "circle-pitch-alignment") {
+    if (property == Property::CirclePitchAlignment) {
         Error error;
         optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setCirclePitchAlignment(*typedValue);
         return nullopt;
+        
     }
-    if (name == "circle-pitch-alignment-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
+    
 
-        setCirclePitchAlignmentTransition(*transition);
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    
+    if (property == Property::CircleRadiusTransition) {
+        setCircleRadiusTransition(*transition);
         return nullopt;
     }
     
-    if (name == "circle-stroke-width") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setCircleStrokeWidth(*typedValue);
+    if (property == Property::CircleColorTransition) {
+        setCircleColorTransition(*transition);
         return nullopt;
     }
-    if (name == "circle-stroke-width-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setCircleStrokeWidthTransition(*transition);
+    
+    if (property == Property::CircleBlurTransition) {
+        setCircleBlurTransition(*transition);
         return nullopt;
     }
     
-    if (name == "circle-stroke-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setCircleStrokeColor(*typedValue);
+    if (property == Property::CircleOpacityTransition) {
+        setCircleOpacityTransition(*transition);
         return nullopt;
     }
-    if (name == "circle-stroke-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setCircleStrokeColorTransition(*transition);
+    
+    if (property == Property::CircleTranslateTransition) {
+        setCircleTranslateTransition(*transition);
         return nullopt;
     }
     
-    if (name == "circle-stroke-opacity") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setCircleStrokeOpacity(*typedValue);
+    if (property == Property::CircleTranslateAnchorTransition) {
+        setCircleTranslateAnchorTransition(*transition);
         return nullopt;
     }
-    if (name == "circle-stroke-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::CirclePitchScaleTransition) {
+        setCirclePitchScaleTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::CirclePitchAlignmentTransition) {
+        setCirclePitchAlignmentTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::CircleStrokeWidthTransition) {
+        setCircleStrokeWidthTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::CircleStrokeColorTransition) {
+        setCircleStrokeColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::CircleStrokeOpacityTransition) {
         setCircleStrokeOpacityTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -654,7 +733,21 @@ optional<Error> CircleLayer::setLayoutProperty(const std::string& name, const Co
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp
index b48e51c566..33f5bbe87c 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -294,154 +295,226 @@ TransitionOptions FillExtrusionLayer::getFillExtrusionBaseTransition() const {
 using namespace conversion;
 
 optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    enum class Property {
+        Unknown,
+        FillExtrusionOpacity,
+        FillExtrusionColor,
+        FillExtrusionTranslate,
+        FillExtrusionTranslateAnchor,
+        FillExtrusionPattern,
+        FillExtrusionHeight,
+        FillExtrusionBase,
+        FillExtrusionOpacityTransition,
+        FillExtrusionColorTransition,
+        FillExtrusionTranslateTransition,
+        FillExtrusionTranslateAnchorTransition,
+        FillExtrusionPatternTransition,
+        FillExtrusionHeightTransition,
+        FillExtrusionBaseTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("fill-extrusion-opacity"):
+        if (name == "fill-extrusion-opacity") {
+            property = Property::FillExtrusionOpacity;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-opacity-transition"):
+        if (name == "fill-extrusion-opacity-transition") {
+            property = Property::FillExtrusionOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-color"):
+        if (name == "fill-extrusion-color") {
+            property = Property::FillExtrusionColor;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-color-transition"):
+        if (name == "fill-extrusion-color-transition") {
+            property = Property::FillExtrusionColorTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-translate"):
+        if (name == "fill-extrusion-translate") {
+            property = Property::FillExtrusionTranslate;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-translate-transition"):
+        if (name == "fill-extrusion-translate-transition") {
+            property = Property::FillExtrusionTranslateTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-translate-anchor"):
+        if (name == "fill-extrusion-translate-anchor") {
+            property = Property::FillExtrusionTranslateAnchor;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-translate-anchor-transition"):
+        if (name == "fill-extrusion-translate-anchor-transition") {
+            property = Property::FillExtrusionTranslateAnchorTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-pattern"):
+        if (name == "fill-extrusion-pattern") {
+            property = Property::FillExtrusionPattern;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-pattern-transition"):
+        if (name == "fill-extrusion-pattern-transition") {
+            property = Property::FillExtrusionPatternTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-height"):
+        if (name == "fill-extrusion-height") {
+            property = Property::FillExtrusionHeight;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-height-transition"):
+        if (name == "fill-extrusion-height-transition") {
+            property = Property::FillExtrusionHeightTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-base"):
+        if (name == "fill-extrusion-base") {
+            property = Property::FillExtrusionBase;
+        }
+        break;
+    case util::hashFNV1a("fill-extrusion-base-transition"):
+        if (name == "fill-extrusion-base-transition") {
+            property = Property::FillExtrusionBaseTransition;
+        }
+        break;
     
-    if (name == "fill-extrusion-opacity") {
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::FillExtrusionOpacity) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillExtrusionOpacity(*typedValue);
         return nullopt;
-    }
-    if (name == "fill-extrusion-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillExtrusionOpacityTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "fill-extrusion-color") {
+    if (property == Property::FillExtrusionColor) {
         Error error;
         optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillExtrusionColor(*typedValue);
         return nullopt;
-    }
-    if (name == "fill-extrusion-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillExtrusionColorTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "fill-extrusion-translate") {
+    if (property == Property::FillExtrusionTranslate) {
         Error error;
         optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillExtrusionTranslate(*typedValue);
         return nullopt;
-    }
-    if (name == "fill-extrusion-translate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillExtrusionTranslateTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "fill-extrusion-translate-anchor") {
+    if (property == Property::FillExtrusionTranslateAnchor) {
         Error error;
         optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillExtrusionTranslateAnchor(*typedValue);
         return nullopt;
-    }
-    if (name == "fill-extrusion-translate-anchor-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillExtrusionTranslateAnchorTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "fill-extrusion-pattern") {
+    if (property == Property::FillExtrusionPattern) {
         Error error;
         optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillExtrusionPattern(*typedValue);
         return nullopt;
-    }
-    if (name == "fill-extrusion-pattern-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillExtrusionPatternTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "fill-extrusion-height") {
+    if (property == Property::FillExtrusionHeight || property == Property::FillExtrusionBase) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
+        
+        if (property == Property::FillExtrusionHeight) {
+            setFillExtrusionHeight(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::FillExtrusionBase) {
+            setFillExtrusionBase(*typedValue);
+            return nullopt;
+        }
+        
+    }
+    
 
-        setFillExtrusionHeight(*typedValue);
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    
+    if (property == Property::FillExtrusionOpacityTransition) {
+        setFillExtrusionOpacityTransition(*transition);
         return nullopt;
     }
-    if (name == "fill-extrusion-height-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillExtrusionHeightTransition(*transition);
+    
+    if (property == Property::FillExtrusionColorTransition) {
+        setFillExtrusionColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "fill-extrusion-base") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setFillExtrusionBase(*typedValue);
+    if (property == Property::FillExtrusionTranslateTransition) {
+        setFillExtrusionTranslateTransition(*transition);
         return nullopt;
     }
-    if (name == "fill-extrusion-base-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::FillExtrusionTranslateAnchorTransition) {
+        setFillExtrusionTranslateAnchorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::FillExtrusionPatternTransition) {
+        setFillExtrusionPatternTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::FillExtrusionHeightTransition) {
+        setFillExtrusionHeightTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::FillExtrusionBaseTransition) {
         setFillExtrusionBaseTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -462,7 +535,21 @@ optional<Error> FillExtrusionLayer::setLayoutProperty(const std::string& name, c
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 04c3bcef3f..c2756dc90e 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -294,154 +295,226 @@ TransitionOptions FillLayer::getFillPatternTransition() const {
 using namespace conversion;
 
 optional<Error> FillLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    enum class Property {
+        Unknown,
+        FillAntialias,
+        FillOpacity,
+        FillColor,
+        FillOutlineColor,
+        FillTranslate,
+        FillTranslateAnchor,
+        FillPattern,
+        FillAntialiasTransition,
+        FillOpacityTransition,
+        FillColorTransition,
+        FillOutlineColorTransition,
+        FillTranslateTransition,
+        FillTranslateAnchorTransition,
+        FillPatternTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("fill-antialias"):
+        if (name == "fill-antialias") {
+            property = Property::FillAntialias;
+        }
+        break;
+    case util::hashFNV1a("fill-antialias-transition"):
+        if (name == "fill-antialias-transition") {
+            property = Property::FillAntialiasTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-opacity"):
+        if (name == "fill-opacity") {
+            property = Property::FillOpacity;
+        }
+        break;
+    case util::hashFNV1a("fill-opacity-transition"):
+        if (name == "fill-opacity-transition") {
+            property = Property::FillOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-color"):
+        if (name == "fill-color") {
+            property = Property::FillColor;
+        }
+        break;
+    case util::hashFNV1a("fill-color-transition"):
+        if (name == "fill-color-transition") {
+            property = Property::FillColorTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-outline-color"):
+        if (name == "fill-outline-color") {
+            property = Property::FillOutlineColor;
+        }
+        break;
+    case util::hashFNV1a("fill-outline-color-transition"):
+        if (name == "fill-outline-color-transition") {
+            property = Property::FillOutlineColorTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-translate"):
+        if (name == "fill-translate") {
+            property = Property::FillTranslate;
+        }
+        break;
+    case util::hashFNV1a("fill-translate-transition"):
+        if (name == "fill-translate-transition") {
+            property = Property::FillTranslateTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-translate-anchor"):
+        if (name == "fill-translate-anchor") {
+            property = Property::FillTranslateAnchor;
+        }
+        break;
+    case util::hashFNV1a("fill-translate-anchor-transition"):
+        if (name == "fill-translate-anchor-transition") {
+            property = Property::FillTranslateAnchorTransition;
+        }
+        break;
+    case util::hashFNV1a("fill-pattern"):
+        if (name == "fill-pattern") {
+            property = Property::FillPattern;
+        }
+        break;
+    case util::hashFNV1a("fill-pattern-transition"):
+        if (name == "fill-pattern-transition") {
+            property = Property::FillPatternTransition;
+        }
+        break;
     
-    if (name == "fill-antialias") {
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::FillAntialias) {
         Error error;
         optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillAntialias(*typedValue);
         return nullopt;
-    }
-    if (name == "fill-antialias-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillAntialiasTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "fill-opacity") {
+    if (property == Property::FillOpacity) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setFillOpacity(*typedValue);
         return nullopt;
+        
     }
-    if (name == "fill-opacity-transition") {
+    
+    if (property == Property::FillColor || property == Property::FillOutlineColor) {
         Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        if (!typedValue) {
             return error;
         }
-
-        setFillOpacityTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::FillColor) {
+            setFillColor(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::FillOutlineColor) {
+            setFillOutlineColor(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "fill-color") {
+    if (property == Property::FillTranslate) {
         Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setFillColor(*typedValue);
+        
+        setFillTranslate(*typedValue);
         return nullopt;
+        
     }
-    if (name == "fill-color-transition") {
+    
+    if (property == Property::FillTranslateAnchor) {
         Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
+        if (!typedValue) {
             return error;
         }
-
-        setFillColorTransition(*transition);
+        
+        setFillTranslateAnchor(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "fill-outline-color") {
+    if (property == Property::FillPattern) {
         Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setFillOutlineColor(*typedValue);
+        
+        setFillPattern(*typedValue);
         return nullopt;
+        
     }
-    if (name == "fill-outline-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
+    
 
-        setFillOutlineColorTransition(*transition);
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    
+    if (property == Property::FillAntialiasTransition) {
+        setFillAntialiasTransition(*transition);
         return nullopt;
     }
     
-    if (name == "fill-translate") {
-        Error error;
-        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setFillTranslate(*typedValue);
+    if (property == Property::FillOpacityTransition) {
+        setFillOpacityTransition(*transition);
         return nullopt;
     }
-    if (name == "fill-translate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillTranslateTransition(*transition);
+    
+    if (property == Property::FillColorTransition) {
+        setFillColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "fill-translate-anchor") {
-        Error error;
-        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setFillTranslateAnchor(*typedValue);
+    if (property == Property::FillOutlineColorTransition) {
+        setFillOutlineColorTransition(*transition);
         return nullopt;
     }
-    if (name == "fill-translate-anchor-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setFillTranslateAnchorTransition(*transition);
+    
+    if (property == Property::FillTranslateTransition) {
+        setFillTranslateTransition(*transition);
         return nullopt;
     }
     
-    if (name == "fill-pattern") {
-        Error error;
-        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setFillPattern(*typedValue);
+    if (property == Property::FillTranslateAnchorTransition) {
+        setFillTranslateAnchorTransition(*transition);
         return nullopt;
     }
-    if (name == "fill-pattern-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::FillPatternTransition) {
         setFillPatternTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -462,7 +535,21 @@ optional<Error> FillLayer::setLayoutProperty(const std::string& name, const Conv
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/heatmap_layer.cpp b/src/mbgl/style/layers/heatmap_layer.cpp
index 443b94c2ce..69499e7d4a 100644
--- a/src/mbgl/style/layers/heatmap_layer.cpp
+++ b/src/mbgl/style/layers/heatmap_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -242,112 +243,163 @@ TransitionOptions HeatmapLayer::getHeatmapOpacityTransition() const {
 using namespace conversion;
 
 optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    
-    if (name == "heatmap-radius") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    enum class Property {
+        Unknown,
+        HeatmapRadius,
+        HeatmapWeight,
+        HeatmapIntensity,
+        HeatmapColor,
+        HeatmapOpacity,
+        HeatmapRadiusTransition,
+        HeatmapWeightTransition,
+        HeatmapIntensityTransition,
+        HeatmapColorTransition,
+        HeatmapOpacityTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("heatmap-radius"):
+        if (name == "heatmap-radius") {
+            property = Property::HeatmapRadius;
         }
-
-        setHeatmapRadius(*typedValue);
-        return nullopt;
-    }
-    if (name == "heatmap-radius-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        break;
+    case util::hashFNV1a("heatmap-radius-transition"):
+        if (name == "heatmap-radius-transition") {
+            property = Property::HeatmapRadiusTransition;
+        }
+        break;
+    case util::hashFNV1a("heatmap-weight"):
+        if (name == "heatmap-weight") {
+            property = Property::HeatmapWeight;
         }
+        break;
+    case util::hashFNV1a("heatmap-weight-transition"):
+        if (name == "heatmap-weight-transition") {
+            property = Property::HeatmapWeightTransition;
+        }
+        break;
+    case util::hashFNV1a("heatmap-intensity"):
+        if (name == "heatmap-intensity") {
+            property = Property::HeatmapIntensity;
+        }
+        break;
+    case util::hashFNV1a("heatmap-intensity-transition"):
+        if (name == "heatmap-intensity-transition") {
+            property = Property::HeatmapIntensityTransition;
+        }
+        break;
+    case util::hashFNV1a("heatmap-color"):
+        if (name == "heatmap-color") {
+            property = Property::HeatmapColor;
+        }
+        break;
+    case util::hashFNV1a("heatmap-color-transition"):
+        if (name == "heatmap-color-transition") {
+            property = Property::HeatmapColorTransition;
+        }
+        break;
+    case util::hashFNV1a("heatmap-opacity"):
+        if (name == "heatmap-opacity") {
+            property = Property::HeatmapOpacity;
+        }
+        break;
+    case util::hashFNV1a("heatmap-opacity-transition"):
+        if (name == "heatmap-opacity-transition") {
+            property = Property::HeatmapOpacityTransition;
+        }
+        break;
+    
+    }
 
-        setHeatmapRadiusTransition(*transition);
-        return nullopt;
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
     }
-    
-    if (name == "heatmap-weight") {
+
+        
+    if (property == Property::HeatmapRadius || property == Property::HeatmapWeight) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setHeatmapWeight(*typedValue);
-        return nullopt;
-    }
-    if (name == "heatmap-weight-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::HeatmapRadius) {
+            setHeatmapRadius(*typedValue);
+            return nullopt;
         }
-
-        setHeatmapWeightTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::HeatmapWeight) {
+            setHeatmapWeight(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "heatmap-intensity") {
+    if (property == Property::HeatmapIntensity || property == Property::HeatmapOpacity) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setHeatmapIntensity(*typedValue);
-        return nullopt;
-    }
-    if (name == "heatmap-intensity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::HeatmapIntensity) {
+            setHeatmapIntensity(*typedValue);
+            return nullopt;
         }
-
-        setHeatmapIntensityTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::HeatmapOpacity) {
+            setHeatmapOpacity(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "heatmap-color") {
+    if (property == Property::HeatmapColor) {
         Error error;
         optional<ColorRampPropertyValue> typedValue = convert<ColorRampPropertyValue>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setHeatmapColor(*typedValue);
         return nullopt;
+        
     }
-    if (name == "heatmap-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
+    
 
-        setHeatmapColorTransition(*transition);
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    
+    if (property == Property::HeatmapRadiusTransition) {
+        setHeatmapRadiusTransition(*transition);
         return nullopt;
     }
     
-    if (name == "heatmap-opacity") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setHeatmapOpacity(*typedValue);
+    if (property == Property::HeatmapWeightTransition) {
+        setHeatmapWeightTransition(*transition);
         return nullopt;
     }
-    if (name == "heatmap-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::HeatmapIntensityTransition) {
+        setHeatmapIntensityTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::HeatmapColorTransition) {
+        setHeatmapColorTransition(*transition);
+        return nullopt;
+    }
+    
+    if (property == Property::HeatmapOpacityTransition) {
         setHeatmapOpacityTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -368,7 +420,21 @@ optional<Error> HeatmapLayer::setLayoutProperty(const std::string& name, const C
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/heatmap_layer_properties.hpp b/src/mbgl/style/layers/heatmap_layer_properties.hpp
index fe7257a78a..4d49a52c72 100644
--- a/src/mbgl/style/layers/heatmap_layer_properties.hpp
+++ b/src/mbgl/style/layers/heatmap_layer_properties.hpp
@@ -24,7 +24,8 @@ struct HeatmapIntensity : PaintProperty<float> {
     static float defaultValue() { return 1; }
 };
 
-using HeatmapColor = ColorRampProperty;
+struct HeatmapColor : ColorRampProperty {
+};
 
 struct HeatmapOpacity : PaintProperty<float> {
     static float defaultValue() { return 1; }
diff --git a/src/mbgl/style/layers/hillshade_layer.cpp b/src/mbgl/style/layers/hillshade_layer.cpp
index 2d8c837baa..9ccdd1567b 100644
--- a/src/mbgl/style/layers/hillshade_layer.cpp
+++ b/src/mbgl/style/layers/hillshade_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -245,133 +246,185 @@ TransitionOptions HillshadeLayer::getHillshadeAccentColorTransition() const {
 using namespace conversion;
 
 optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    enum class Property {
+        Unknown,
+        HillshadeIlluminationDirection,
+        HillshadeIlluminationAnchor,
+        HillshadeExaggeration,
+        HillshadeShadowColor,
+        HillshadeHighlightColor,
+        HillshadeAccentColor,
+        HillshadeIlluminationDirectionTransition,
+        HillshadeIlluminationAnchorTransition,
+        HillshadeExaggerationTransition,
+        HillshadeShadowColorTransition,
+        HillshadeHighlightColorTransition,
+        HillshadeAccentColorTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("hillshade-illumination-direction"):
+        if (name == "hillshade-illumination-direction") {
+            property = Property::HillshadeIlluminationDirection;
+        }
+        break;
+    case util::hashFNV1a("hillshade-illumination-direction-transition"):
+        if (name == "hillshade-illumination-direction-transition") {
+            property = Property::HillshadeIlluminationDirectionTransition;
+        }
+        break;
+    case util::hashFNV1a("hillshade-illumination-anchor"):
+        if (name == "hillshade-illumination-anchor") {
+            property = Property::HillshadeIlluminationAnchor;
+        }
+        break;
+    case util::hashFNV1a("hillshade-illumination-anchor-transition"):
+        if (name == "hillshade-illumination-anchor-transition") {
+            property = Property::HillshadeIlluminationAnchorTransition;
+        }
+        break;
+    case util::hashFNV1a("hillshade-exaggeration"):
+        if (name == "hillshade-exaggeration") {
+            property = Property::HillshadeExaggeration;
+        }
+        break;
+    case util::hashFNV1a("hillshade-exaggeration-transition"):
+        if (name == "hillshade-exaggeration-transition") {
+            property = Property::HillshadeExaggerationTransition;
+        }
+        break;
+    case util::hashFNV1a("hillshade-shadow-color"):
+        if (name == "hillshade-shadow-color") {
+            property = Property::HillshadeShadowColor;
+        }
+        break;
+    case util::hashFNV1a("hillshade-shadow-color-transition"):
+        if (name == "hillshade-shadow-color-transition") {
+            property = Property::HillshadeShadowColorTransition;
+        }
+        break;
+    case util::hashFNV1a("hillshade-highlight-color"):
+        if (name == "hillshade-highlight-color") {
+            property = Property::HillshadeHighlightColor;
+        }
+        break;
+    case util::hashFNV1a("hillshade-highlight-color-transition"):
+        if (name == "hillshade-highlight-color-transition") {
+            property = Property::HillshadeHighlightColorTransition;
+        }
+        break;
+    case util::hashFNV1a("hillshade-accent-color"):
+        if (name == "hillshade-accent-color") {
+            property = Property::HillshadeAccentColor;
+        }
+        break;
+    case util::hashFNV1a("hillshade-accent-color-transition"):
+        if (name == "hillshade-accent-color-transition") {
+            property = Property::HillshadeAccentColorTransition;
+        }
+        break;
     
-    if (name == "hillshade-illumination-direction") {
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::HillshadeIlluminationDirection || property == Property::HillshadeExaggeration) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setHillshadeIlluminationDirection(*typedValue);
-        return nullopt;
-    }
-    if (name == "hillshade-illumination-direction-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::HillshadeIlluminationDirection) {
+            setHillshadeIlluminationDirection(*typedValue);
+            return nullopt;
         }
-
-        setHillshadeIlluminationDirectionTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::HillshadeExaggeration) {
+            setHillshadeExaggeration(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "hillshade-illumination-anchor") {
+    if (property == Property::HillshadeIlluminationAnchor) {
         Error error;
         optional<PropertyValue<HillshadeIlluminationAnchorType>> typedValue = convert<PropertyValue<HillshadeIlluminationAnchorType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setHillshadeIlluminationAnchor(*typedValue);
         return nullopt;
-    }
-    if (name == "hillshade-illumination-anchor-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setHillshadeIlluminationAnchorTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "hillshade-exaggeration") {
+    if (property == Property::HillshadeShadowColor || property == Property::HillshadeHighlightColor || property == Property::HillshadeAccentColor) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setHillshadeExaggeration(*typedValue);
-        return nullopt;
-    }
-    if (name == "hillshade-exaggeration-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::HillshadeShadowColor) {
+            setHillshadeShadowColor(*typedValue);
+            return nullopt;
         }
-
-        setHillshadeExaggerationTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::HillshadeHighlightColor) {
+            setHillshadeHighlightColor(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::HillshadeAccentColor) {
+            setHillshadeAccentColor(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "hillshade-shadow-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
 
-        setHillshadeShadowColor(*typedValue);
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    
+    if (property == Property::HillshadeIlluminationDirectionTransition) {
+        setHillshadeIlluminationDirectionTransition(*transition);
         return nullopt;
     }
-    if (name == "hillshade-shadow-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setHillshadeShadowColorTransition(*transition);
+    
+    if (property == Property::HillshadeIlluminationAnchorTransition) {
+        setHillshadeIlluminationAnchorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "hillshade-highlight-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setHillshadeHighlightColor(*typedValue);
+    if (property == Property::HillshadeExaggerationTransition) {
+        setHillshadeExaggerationTransition(*transition);
         return nullopt;
     }
-    if (name == "hillshade-highlight-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setHillshadeHighlightColorTransition(*transition);
+    
+    if (property == Property::HillshadeShadowColorTransition) {
+        setHillshadeShadowColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "hillshade-accent-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setHillshadeAccentColor(*typedValue);
+    if (property == Property::HillshadeHighlightColorTransition) {
+        setHillshadeHighlightColorTransition(*transition);
         return nullopt;
     }
-    if (name == "hillshade-accent-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::HillshadeAccentColorTransition) {
         setHillshadeAccentColorTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -392,7 +445,21 @@ optional<Error> HillshadeLayer::setLayoutProperty(const std::string& name, const
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 7555054bdb..8a6db749cf 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -14,6 +14,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -178,28 +179,78 @@ TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>T
 using namespace conversion;
 
 optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string& name, const Convertible& value) {
-    <% for (const property of paintProperties) { %>
-    if (name == "<%- property.name %>") {
-        Error error;
-        optional<<%- propertyValueType(property) %>> typedValue = convert<<%- propertyValueType(property) %>>(value, error, <%- property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven' %>, <%- property.name === 'icon-image' || property.name === 'text-field' %>);
-        if (!typedValue) {
-            return error;
+    enum class Property {
+        Unknown,
+<% for (const property of paintProperties) { -%>
+        <%- camelize(property.name) %>,
+<% } -%>
+<% for (const property of paintProperties) { -%>
+        <%- camelize(property.name) %>Transition,
+<% } -%>
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    <% for (const property of paintProperties) { -%>
+case util::hashFNV1a("<%- property.name %>"):
+        if (name == "<%- property.name %>") {
+            property = Property::<%- camelize(property.name) %>;
         }
+        break;
+    case util::hashFNV1a("<%- property.name %>-transition"):
+        if (name == "<%- property.name %>-transition") {
+            property = Property::<%- camelize(property.name) %>Transition;
+        }
+        break;
+    <% } %>
+    }
 
-        set<%- camelize(property.name) %>(*typedValue);
-        return nullopt;
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
     }
-    if (name == "<%- property.name %>-transition") {
+
+    <%
+        const paintConversions = {};
+        for (const property of paintProperties) {
+            const dataDriven = property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven';
+            const convertTokens = property.name === 'icon-image' || property.name === 'text-field';
+            const conversion = `optional<${propertyValueType(property)}> typedValue = convert<${propertyValueType(property)}>(value, error, ${dataDriven}, ${convertTokens})`;
+            paintConversions[conversion] = paintConversions[conversion] || [];
+            paintConversions[conversion].push(property);
+        }
+    -%>
+    <% for (const key in paintConversions) {
+        const properties = paintConversions[key];
+    %>
+    if (<%- properties.map(p => `property == Property::${camelize(p.name)}`).join(' || ') %>) {
         Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
+        <%- key %>;
+        if (!typedValue) {
             return error;
         }
+        <% if (properties.length == 1) { %>
+        set<%- camelize(properties[0].name) %>(*typedValue);
+        return nullopt;
+        <% } else for (const property of properties) { %>
+        if (property == Property::<%- camelize(property.name) %>) {
+            set<%- camelize(property.name) %>(*typedValue);
+            return nullopt;
+        }
+        <% } %>
+    }
+    <% } %>
 
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
+    }
+    <% for (const property of paintProperties) { %>
+    if (property == Property::<%- camelize(property.name) %>Transition) {
         set<%- camelize(property.name) %>Transition(*transition);
         return nullopt;
     }
-    <% } -%>
+    <% } %>
 
     return Error { "layer doesn't support this property" };
 }
@@ -221,18 +272,58 @@ optional<Error> <%- camelize(type) %>Layer::setLayoutProperty(const std::string&
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+<% for (const property of layoutProperties) { -%>
+        <%- camelize(property.name) %>,
+<% } -%>
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     <% for (const property of layoutProperties) { %>
-    if (name == "<%- property.name %>") {
+    case util::hashFNV1a("<%- property.name %>"):
+        if (name == "<%- property.name %>") {
+            property = Property::<%- camelize(property.name) %>;
+        }
+        break;
+    <% } %>
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+    <%
+        const layoutConversions = {};
+        for (const property of layoutProperties) {
+            const dataDriven = property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven';
+            const convertTokens = property.name === 'icon-image' || property.name === 'text-field';
+            const conversion = `optional<${propertyValueType(property)}> typedValue = convert<${propertyValueType(property)}>(value, error, ${dataDriven}, ${convertTokens})`;
+            layoutConversions[conversion] = layoutConversions[conversion] || [];
+            layoutConversions[conversion].push(property);
+        }
+    -%>
+    <% for (const key in layoutConversions) {
+        const properties = layoutConversions[key];
+    %>
+    if (<%- properties.map(p => `property == Property::${camelize(p.name)}`).join(' || ') %>) {
         Error error;
-        optional<<%- propertyValueType(property) %>> typedValue = convert<<%- propertyValueType(property) %>>(value, error, <%- property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven' %>, <%- property.name === 'icon-image' || property.name === 'text-field' %>);
+        <%- key %>;
         if (!typedValue) {
             return error;
         }
-
-        set<%- camelize(property.name) %>(*typedValue);
+        <% if (properties.length == 1) { %>
+        set<%- camelize(properties[0].name) %>(*typedValue);
         return nullopt;
+        <% } else for (const property of properties) { %>
+        if (property == Property::<%- camelize(property.name) %>) {
+            set<%- camelize(property.name) %>(*typedValue);
+            return nullopt;
+        }
+        <% } %>
     }
-    <% } -%>
+    <% } %>
 
     return Error { "layer doesn't support this property" };
 }
diff --git a/src/mbgl/style/layers/layer_properties.hpp.ejs b/src/mbgl/style/layers/layer_properties.hpp.ejs
index 5b774933a6..694d9a62b7 100644
--- a/src/mbgl/style/layers/layer_properties.hpp.ejs
+++ b/src/mbgl/style/layers/layer_properties.hpp.ejs
@@ -26,7 +26,8 @@ struct <%- camelize(property.name) %> : <%- layoutPropertyType(property, type) %
 <% } -%>
 <% for (const property of paintProperties) { -%>
 <%   if (property['property-type'] === 'color-ramp') { -%>
-using <%- camelize(property.name) %> = ColorRampProperty;
+struct <%- camelize(property.name) %> : ColorRampProperty {
+};
 <%   } else { -%>
 struct <%- camelize(property.name) %> : <%- paintPropertyType(property, type) %> {
     static <%- evaluatedType(property) %> defaultValue() { return <%- defaultValue(property) %>; }
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index c3203f84e4..cc6bfdde37 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -440,217 +441,292 @@ TransitionOptions LineLayer::getLinePatternTransition() const {
 using namespace conversion;
 
 optional<Error> LineLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    enum class Property {
+        Unknown,
+        LineOpacity,
+        LineColor,
+        LineTranslate,
+        LineTranslateAnchor,
+        LineWidth,
+        LineGapWidth,
+        LineOffset,
+        LineBlur,
+        LineDasharray,
+        LinePattern,
+        LineOpacityTransition,
+        LineColorTransition,
+        LineTranslateTransition,
+        LineTranslateAnchorTransition,
+        LineWidthTransition,
+        LineGapWidthTransition,
+        LineOffsetTransition,
+        LineBlurTransition,
+        LineDasharrayTransition,
+        LinePatternTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("line-opacity"):
+        if (name == "line-opacity") {
+            property = Property::LineOpacity;
+        }
+        break;
+    case util::hashFNV1a("line-opacity-transition"):
+        if (name == "line-opacity-transition") {
+            property = Property::LineOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("line-color"):
+        if (name == "line-color") {
+            property = Property::LineColor;
+        }
+        break;
+    case util::hashFNV1a("line-color-transition"):
+        if (name == "line-color-transition") {
+            property = Property::LineColorTransition;
+        }
+        break;
+    case util::hashFNV1a("line-translate"):
+        if (name == "line-translate") {
+            property = Property::LineTranslate;
+        }
+        break;
+    case util::hashFNV1a("line-translate-transition"):
+        if (name == "line-translate-transition") {
+            property = Property::LineTranslateTransition;
+        }
+        break;
+    case util::hashFNV1a("line-translate-anchor"):
+        if (name == "line-translate-anchor") {
+            property = Property::LineTranslateAnchor;
+        }
+        break;
+    case util::hashFNV1a("line-translate-anchor-transition"):
+        if (name == "line-translate-anchor-transition") {
+            property = Property::LineTranslateAnchorTransition;
+        }
+        break;
+    case util::hashFNV1a("line-width"):
+        if (name == "line-width") {
+            property = Property::LineWidth;
+        }
+        break;
+    case util::hashFNV1a("line-width-transition"):
+        if (name == "line-width-transition") {
+            property = Property::LineWidthTransition;
+        }
+        break;
+    case util::hashFNV1a("line-gap-width"):
+        if (name == "line-gap-width") {
+            property = Property::LineGapWidth;
+        }
+        break;
+    case util::hashFNV1a("line-gap-width-transition"):
+        if (name == "line-gap-width-transition") {
+            property = Property::LineGapWidthTransition;
+        }
+        break;
+    case util::hashFNV1a("line-offset"):
+        if (name == "line-offset") {
+            property = Property::LineOffset;
+        }
+        break;
+    case util::hashFNV1a("line-offset-transition"):
+        if (name == "line-offset-transition") {
+            property = Property::LineOffsetTransition;
+        }
+        break;
+    case util::hashFNV1a("line-blur"):
+        if (name == "line-blur") {
+            property = Property::LineBlur;
+        }
+        break;
+    case util::hashFNV1a("line-blur-transition"):
+        if (name == "line-blur-transition") {
+            property = Property::LineBlurTransition;
+        }
+        break;
+    case util::hashFNV1a("line-dasharray"):
+        if (name == "line-dasharray") {
+            property = Property::LineDasharray;
+        }
+        break;
+    case util::hashFNV1a("line-dasharray-transition"):
+        if (name == "line-dasharray-transition") {
+            property = Property::LineDasharrayTransition;
+        }
+        break;
+    case util::hashFNV1a("line-pattern"):
+        if (name == "line-pattern") {
+            property = Property::LinePattern;
+        }
+        break;
+    case util::hashFNV1a("line-pattern-transition"):
+        if (name == "line-pattern-transition") {
+            property = Property::LinePatternTransition;
+        }
+        break;
     
-    if (name == "line-opacity") {
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::LineOpacity || property == Property::LineWidth || property == Property::LineGapWidth || property == Property::LineOffset || property == Property::LineBlur) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setLineOpacity(*typedValue);
-        return nullopt;
-    }
-    if (name == "line-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::LineOpacity) {
+            setLineOpacity(*typedValue);
+            return nullopt;
         }
-
-        setLineOpacityTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::LineWidth) {
+            setLineWidth(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::LineGapWidth) {
+            setLineGapWidth(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::LineOffset) {
+            setLineOffset(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::LineBlur) {
+            setLineBlur(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "line-color") {
+    if (property == Property::LineColor) {
         Error error;
         optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setLineColor(*typedValue);
         return nullopt;
-    }
-    if (name == "line-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setLineColorTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "line-translate") {
+    if (property == Property::LineTranslate) {
         Error error;
         optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setLineTranslate(*typedValue);
         return nullopt;
-    }
-    if (name == "line-translate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setLineTranslateTransition(*transition);
-        return nullopt;
+        
     }
     
-    if (name == "line-translate-anchor") {
+    if (property == Property::LineTranslateAnchor) {
         Error error;
         optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setLineTranslateAnchor(*typedValue);
         return nullopt;
+        
     }
-    if (name == "line-translate-anchor-transition") {
+    
+    if (property == Property::LineDasharray) {
         Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
+        optional<PropertyValue<std::vector<float>>> typedValue = convert<PropertyValue<std::vector<float>>>(value, error, false, false);
+        if (!typedValue) {
             return error;
         }
-
-        setLineTranslateAnchorTransition(*transition);
+        
+        setLineDasharray(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "line-width") {
+    if (property == Property::LinePattern) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setLineWidth(*typedValue);
+        
+        setLinePattern(*typedValue);
         return nullopt;
+        
     }
-    if (name == "line-width-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
+    
 
-        setLineWidthTransition(*transition);
-        return nullopt;
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
     }
     
-    if (name == "line-gap-width") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setLineGapWidth(*typedValue);
+    if (property == Property::LineOpacityTransition) {
+        setLineOpacityTransition(*transition);
         return nullopt;
     }
-    if (name == "line-gap-width-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setLineGapWidthTransition(*transition);
+    
+    if (property == Property::LineColorTransition) {
+        setLineColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "line-offset") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setLineOffset(*typedValue);
+    if (property == Property::LineTranslateTransition) {
+        setLineTranslateTransition(*transition);
         return nullopt;
     }
-    if (name == "line-offset-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setLineOffsetTransition(*transition);
+    
+    if (property == Property::LineTranslateAnchorTransition) {
+        setLineTranslateAnchorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "line-blur") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setLineBlur(*typedValue);
+    if (property == Property::LineWidthTransition) {
+        setLineWidthTransition(*transition);
         return nullopt;
     }
-    if (name == "line-blur-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setLineBlurTransition(*transition);
+    
+    if (property == Property::LineGapWidthTransition) {
+        setLineGapWidthTransition(*transition);
         return nullopt;
     }
     
-    if (name == "line-dasharray") {
-        Error error;
-        optional<PropertyValue<std::vector<float>>> typedValue = convert<PropertyValue<std::vector<float>>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setLineDasharray(*typedValue);
+    if (property == Property::LineOffsetTransition) {
+        setLineOffsetTransition(*transition);
         return nullopt;
     }
-    if (name == "line-dasharray-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setLineDasharrayTransition(*transition);
+    
+    if (property == Property::LineBlurTransition) {
+        setLineBlurTransition(*transition);
         return nullopt;
     }
     
-    if (name == "line-pattern") {
-        Error error;
-        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setLinePattern(*typedValue);
+    if (property == Property::LineDasharrayTransition) {
+        setLineDasharrayTransition(*transition);
         return nullopt;
     }
-    if (name == "line-pattern-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::LinePatternTransition) {
         setLinePatternTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -671,51 +747,92 @@ optional<Error> LineLayer::setLayoutProperty(const std::string& name, const Conv
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+        LineCap,
+        LineJoin,
+        LineMiterLimit,
+        LineRoundLimit,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    
+    case util::hashFNV1a("line-cap"):
+        if (name == "line-cap") {
+            property = Property::LineCap;
+        }
+        break;
     
-    if (name == "line-cap") {
+    case util::hashFNV1a("line-join"):
+        if (name == "line-join") {
+            property = Property::LineJoin;
+        }
+        break;
+    
+    case util::hashFNV1a("line-miter-limit"):
+        if (name == "line-miter-limit") {
+            property = Property::LineMiterLimit;
+        }
+        break;
+    
+    case util::hashFNV1a("line-round-limit"):
+        if (name == "line-round-limit") {
+            property = Property::LineRoundLimit;
+        }
+        break;
+    
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::LineCap) {
         Error error;
         optional<PropertyValue<LineCapType>> typedValue = convert<PropertyValue<LineCapType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setLineCap(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "line-join") {
+    if (property == Property::LineJoin) {
         Error error;
         optional<PropertyValue<LineJoinType>> typedValue = convert<PropertyValue<LineJoinType>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
+        
         setLineJoin(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "line-miter-limit") {
+    if (property == Property::LineMiterLimit || property == Property::LineRoundLimit) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setLineMiterLimit(*typedValue);
-        return nullopt;
-    }
-    
-    if (name == "line-round-limit") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+        
+        if (property == Property::LineMiterLimit) {
+            setLineMiterLimit(*typedValue);
+            return nullopt;
         }
-
-        setLineRoundLimit(*typedValue);
-        return nullopt;
+        
+        if (property == Property::LineRoundLimit) {
+            setLineRoundLimit(*typedValue);
+            return nullopt;
+        }
+        
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index 0eba8ef886..da3f7f8a18 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -299,175 +300,220 @@ TransitionOptions RasterLayer::getRasterFadeDurationTransition() const {
 using namespace conversion;
 
 optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Convertible& value) {
-    
-    if (name == "raster-opacity") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    enum class Property {
+        Unknown,
+        RasterOpacity,
+        RasterHueRotate,
+        RasterBrightnessMin,
+        RasterBrightnessMax,
+        RasterSaturation,
+        RasterContrast,
+        RasterResampling,
+        RasterFadeDuration,
+        RasterOpacityTransition,
+        RasterHueRotateTransition,
+        RasterBrightnessMinTransition,
+        RasterBrightnessMaxTransition,
+        RasterSaturationTransition,
+        RasterContrastTransition,
+        RasterResamplingTransition,
+        RasterFadeDurationTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("raster-opacity"):
+        if (name == "raster-opacity") {
+            property = Property::RasterOpacity;
         }
-
-        setRasterOpacity(*typedValue);
-        return nullopt;
-    }
-    if (name == "raster-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        break;
+    case util::hashFNV1a("raster-opacity-transition"):
+        if (name == "raster-opacity-transition") {
+            property = Property::RasterOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-hue-rotate"):
+        if (name == "raster-hue-rotate") {
+            property = Property::RasterHueRotate;
+        }
+        break;
+    case util::hashFNV1a("raster-hue-rotate-transition"):
+        if (name == "raster-hue-rotate-transition") {
+            property = Property::RasterHueRotateTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-brightness-min"):
+        if (name == "raster-brightness-min") {
+            property = Property::RasterBrightnessMin;
+        }
+        break;
+    case util::hashFNV1a("raster-brightness-min-transition"):
+        if (name == "raster-brightness-min-transition") {
+            property = Property::RasterBrightnessMinTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-brightness-max"):
+        if (name == "raster-brightness-max") {
+            property = Property::RasterBrightnessMax;
+        }
+        break;
+    case util::hashFNV1a("raster-brightness-max-transition"):
+        if (name == "raster-brightness-max-transition") {
+            property = Property::RasterBrightnessMaxTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-saturation"):
+        if (name == "raster-saturation") {
+            property = Property::RasterSaturation;
         }
+        break;
+    case util::hashFNV1a("raster-saturation-transition"):
+        if (name == "raster-saturation-transition") {
+            property = Property::RasterSaturationTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-contrast"):
+        if (name == "raster-contrast") {
+            property = Property::RasterContrast;
+        }
+        break;
+    case util::hashFNV1a("raster-contrast-transition"):
+        if (name == "raster-contrast-transition") {
+            property = Property::RasterContrastTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-resampling"):
+        if (name == "raster-resampling") {
+            property = Property::RasterResampling;
+        }
+        break;
+    case util::hashFNV1a("raster-resampling-transition"):
+        if (name == "raster-resampling-transition") {
+            property = Property::RasterResamplingTransition;
+        }
+        break;
+    case util::hashFNV1a("raster-fade-duration"):
+        if (name == "raster-fade-duration") {
+            property = Property::RasterFadeDuration;
+        }
+        break;
+    case util::hashFNV1a("raster-fade-duration-transition"):
+        if (name == "raster-fade-duration-transition") {
+            property = Property::RasterFadeDurationTransition;
+        }
+        break;
+    
+    }
 
-        setRasterOpacityTransition(*transition);
-        return nullopt;
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
     }
-    
-    if (name == "raster-hue-rotate") {
+
+        
+    if (property == Property::RasterOpacity || property == Property::RasterHueRotate || property == Property::RasterBrightnessMin || property == Property::RasterBrightnessMax || property == Property::RasterSaturation || property == Property::RasterContrast || property == Property::RasterFadeDuration) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setRasterHueRotate(*typedValue);
-        return nullopt;
-    }
-    if (name == "raster-hue-rotate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::RasterOpacity) {
+            setRasterOpacity(*typedValue);
+            return nullopt;
         }
-
-        setRasterHueRotateTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::RasterHueRotate) {
+            setRasterHueRotate(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::RasterBrightnessMin) {
+            setRasterBrightnessMin(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::RasterBrightnessMax) {
+            setRasterBrightnessMax(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::RasterSaturation) {
+            setRasterSaturation(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::RasterContrast) {
+            setRasterContrast(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::RasterFadeDuration) {
+            setRasterFadeDuration(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "raster-brightness-min") {
+    if (property == Property::RasterResampling) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        optional<PropertyValue<RasterResamplingType>> typedValue = convert<PropertyValue<RasterResamplingType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setRasterBrightnessMin(*typedValue);
+        
+        setRasterResampling(*typedValue);
         return nullopt;
+        
     }
-    if (name == "raster-brightness-min-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
+    
 
-        setRasterBrightnessMinTransition(*transition);
-        return nullopt;
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
     }
     
-    if (name == "raster-brightness-max") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setRasterBrightnessMax(*typedValue);
+    if (property == Property::RasterOpacityTransition) {
+        setRasterOpacityTransition(*transition);
         return nullopt;
     }
-    if (name == "raster-brightness-max-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setRasterBrightnessMaxTransition(*transition);
+    
+    if (property == Property::RasterHueRotateTransition) {
+        setRasterHueRotateTransition(*transition);
         return nullopt;
     }
     
-    if (name == "raster-saturation") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setRasterSaturation(*typedValue);
+    if (property == Property::RasterBrightnessMinTransition) {
+        setRasterBrightnessMinTransition(*transition);
         return nullopt;
     }
-    if (name == "raster-saturation-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setRasterSaturationTransition(*transition);
+    
+    if (property == Property::RasterBrightnessMaxTransition) {
+        setRasterBrightnessMaxTransition(*transition);
         return nullopt;
     }
     
-    if (name == "raster-contrast") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setRasterContrast(*typedValue);
+    if (property == Property::RasterSaturationTransition) {
+        setRasterSaturationTransition(*transition);
         return nullopt;
     }
-    if (name == "raster-contrast-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::RasterContrastTransition) {
         setRasterContrastTransition(*transition);
         return nullopt;
     }
     
-    if (name == "raster-resampling") {
-        Error error;
-        optional<PropertyValue<RasterResamplingType>> typedValue = convert<PropertyValue<RasterResamplingType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setRasterResampling(*typedValue);
-        return nullopt;
-    }
-    if (name == "raster-resampling-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::RasterResamplingTransition) {
         setRasterResamplingTransition(*transition);
         return nullopt;
     }
     
-    if (name == "raster-fade-duration") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setRasterFadeDuration(*typedValue);
-        return nullopt;
-    }
-    if (name == "raster-fade-duration-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::RasterFadeDurationTransition) {
         setRasterFadeDurationTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -488,7 +534,21 @@ optional<Error> RasterLayer::setLayoutProperty(const std::string& name, const Co
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index bb5b317a38..e7cba19ea5 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/style/conversion/property_value.hpp>
 #include <mbgl/style/conversion/transition_options.hpp>
 #include <mbgl/style/conversion/json.hpp>
+#include <mbgl/util/fnv_hash.hpp>
 
 namespace mbgl {
 namespace style {
@@ -1060,301 +1061,372 @@ TransitionOptions SymbolLayer::getTextTranslateAnchorTransition() const {
 using namespace conversion;
 
 optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Convertible& value) {
+    enum class Property {
+        Unknown,
+        IconOpacity,
+        IconColor,
+        IconHaloColor,
+        IconHaloWidth,
+        IconHaloBlur,
+        IconTranslate,
+        IconTranslateAnchor,
+        TextOpacity,
+        TextColor,
+        TextHaloColor,
+        TextHaloWidth,
+        TextHaloBlur,
+        TextTranslate,
+        TextTranslateAnchor,
+        IconOpacityTransition,
+        IconColorTransition,
+        IconHaloColorTransition,
+        IconHaloWidthTransition,
+        IconHaloBlurTransition,
+        IconTranslateTransition,
+        IconTranslateAnchorTransition,
+        TextOpacityTransition,
+        TextColorTransition,
+        TextHaloColorTransition,
+        TextHaloWidthTransition,
+        TextHaloBlurTransition,
+        TextTranslateTransition,
+        TextTranslateAnchorTransition,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
+    case util::hashFNV1a("icon-opacity"):
+        if (name == "icon-opacity") {
+            property = Property::IconOpacity;
+        }
+        break;
+    case util::hashFNV1a("icon-opacity-transition"):
+        if (name == "icon-opacity-transition") {
+            property = Property::IconOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("icon-color"):
+        if (name == "icon-color") {
+            property = Property::IconColor;
+        }
+        break;
+    case util::hashFNV1a("icon-color-transition"):
+        if (name == "icon-color-transition") {
+            property = Property::IconColorTransition;
+        }
+        break;
+    case util::hashFNV1a("icon-halo-color"):
+        if (name == "icon-halo-color") {
+            property = Property::IconHaloColor;
+        }
+        break;
+    case util::hashFNV1a("icon-halo-color-transition"):
+        if (name == "icon-halo-color-transition") {
+            property = Property::IconHaloColorTransition;
+        }
+        break;
+    case util::hashFNV1a("icon-halo-width"):
+        if (name == "icon-halo-width") {
+            property = Property::IconHaloWidth;
+        }
+        break;
+    case util::hashFNV1a("icon-halo-width-transition"):
+        if (name == "icon-halo-width-transition") {
+            property = Property::IconHaloWidthTransition;
+        }
+        break;
+    case util::hashFNV1a("icon-halo-blur"):
+        if (name == "icon-halo-blur") {
+            property = Property::IconHaloBlur;
+        }
+        break;
+    case util::hashFNV1a("icon-halo-blur-transition"):
+        if (name == "icon-halo-blur-transition") {
+            property = Property::IconHaloBlurTransition;
+        }
+        break;
+    case util::hashFNV1a("icon-translate"):
+        if (name == "icon-translate") {
+            property = Property::IconTranslate;
+        }
+        break;
+    case util::hashFNV1a("icon-translate-transition"):
+        if (name == "icon-translate-transition") {
+            property = Property::IconTranslateTransition;
+        }
+        break;
+    case util::hashFNV1a("icon-translate-anchor"):
+        if (name == "icon-translate-anchor") {
+            property = Property::IconTranslateAnchor;
+        }
+        break;
+    case util::hashFNV1a("icon-translate-anchor-transition"):
+        if (name == "icon-translate-anchor-transition") {
+            property = Property::IconTranslateAnchorTransition;
+        }
+        break;
+    case util::hashFNV1a("text-opacity"):
+        if (name == "text-opacity") {
+            property = Property::TextOpacity;
+        }
+        break;
+    case util::hashFNV1a("text-opacity-transition"):
+        if (name == "text-opacity-transition") {
+            property = Property::TextOpacityTransition;
+        }
+        break;
+    case util::hashFNV1a("text-color"):
+        if (name == "text-color") {
+            property = Property::TextColor;
+        }
+        break;
+    case util::hashFNV1a("text-color-transition"):
+        if (name == "text-color-transition") {
+            property = Property::TextColorTransition;
+        }
+        break;
+    case util::hashFNV1a("text-halo-color"):
+        if (name == "text-halo-color") {
+            property = Property::TextHaloColor;
+        }
+        break;
+    case util::hashFNV1a("text-halo-color-transition"):
+        if (name == "text-halo-color-transition") {
+            property = Property::TextHaloColorTransition;
+        }
+        break;
+    case util::hashFNV1a("text-halo-width"):
+        if (name == "text-halo-width") {
+            property = Property::TextHaloWidth;
+        }
+        break;
+    case util::hashFNV1a("text-halo-width-transition"):
+        if (name == "text-halo-width-transition") {
+            property = Property::TextHaloWidthTransition;
+        }
+        break;
+    case util::hashFNV1a("text-halo-blur"):
+        if (name == "text-halo-blur") {
+            property = Property::TextHaloBlur;
+        }
+        break;
+    case util::hashFNV1a("text-halo-blur-transition"):
+        if (name == "text-halo-blur-transition") {
+            property = Property::TextHaloBlurTransition;
+        }
+        break;
+    case util::hashFNV1a("text-translate"):
+        if (name == "text-translate") {
+            property = Property::TextTranslate;
+        }
+        break;
+    case util::hashFNV1a("text-translate-transition"):
+        if (name == "text-translate-transition") {
+            property = Property::TextTranslateTransition;
+        }
+        break;
+    case util::hashFNV1a("text-translate-anchor"):
+        if (name == "text-translate-anchor") {
+            property = Property::TextTranslateAnchor;
+        }
+        break;
+    case util::hashFNV1a("text-translate-anchor-transition"):
+        if (name == "text-translate-anchor-transition") {
+            property = Property::TextTranslateAnchorTransition;
+        }
+        break;
     
-    if (name == "icon-opacity") {
+    }
+
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
+    }
+
+        
+    if (property == Property::IconOpacity || property == Property::IconHaloWidth || property == Property::IconHaloBlur || property == Property::TextOpacity || property == Property::TextHaloWidth || property == Property::TextHaloBlur) {
         Error error;
         optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setIconOpacity(*typedValue);
-        return nullopt;
-    }
-    if (name == "icon-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::IconOpacity) {
+            setIconOpacity(*typedValue);
+            return nullopt;
         }
-
-        setIconOpacityTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::IconHaloWidth) {
+            setIconHaloWidth(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconHaloBlur) {
+            setIconHaloBlur(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextOpacity) {
+            setTextOpacity(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextHaloWidth) {
+            setTextHaloWidth(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextHaloBlur) {
+            setTextHaloBlur(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "icon-color") {
+    if (property == Property::IconColor || property == Property::IconHaloColor || property == Property::TextColor || property == Property::TextHaloColor) {
         Error error;
         optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setIconColor(*typedValue);
-        return nullopt;
-    }
-    if (name == "icon-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::IconColor) {
+            setIconColor(*typedValue);
+            return nullopt;
         }
-
-        setIconColorTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::IconHaloColor) {
+            setIconHaloColor(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextColor) {
+            setTextColor(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextHaloColor) {
+            setTextHaloColor(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "icon-halo-color") {
+    if (property == Property::IconTranslate || property == Property::TextTranslate) {
         Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setIconHaloColor(*typedValue);
-        return nullopt;
-    }
-    if (name == "icon-halo-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::IconTranslate) {
+            setIconTranslate(*typedValue);
+            return nullopt;
         }
-
-        setIconHaloColorTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::TextTranslate) {
+            setTextTranslate(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "icon-halo-width") {
+    if (property == Property::IconTranslateAnchor || property == Property::TextTranslateAnchor) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setIconHaloWidth(*typedValue);
-        return nullopt;
-    }
-    if (name == "icon-halo-width-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
+        
+        if (property == Property::IconTranslateAnchor) {
+            setIconTranslateAnchor(*typedValue);
+            return nullopt;
         }
-
-        setIconHaloWidthTransition(*transition);
-        return nullopt;
+        
+        if (property == Property::TextTranslateAnchor) {
+            setTextTranslateAnchor(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "icon-halo-blur") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
 
-        setIconHaloBlur(*typedValue);
-        return nullopt;
+    Error error;
+    optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
+    if (!transition) {
+        return error;
     }
-    if (name == "icon-halo-blur-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setIconHaloBlurTransition(*transition);
+    
+    if (property == Property::IconOpacityTransition) {
+        setIconOpacityTransition(*transition);
         return nullopt;
     }
     
-    if (name == "icon-translate") {
-        Error error;
-        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setIconTranslate(*typedValue);
+    if (property == Property::IconColorTransition) {
+        setIconColorTransition(*transition);
         return nullopt;
     }
-    if (name == "icon-translate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setIconTranslateTransition(*transition);
+    
+    if (property == Property::IconHaloColorTransition) {
+        setIconHaloColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "icon-translate-anchor") {
-        Error error;
-        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setIconTranslateAnchor(*typedValue);
+    if (property == Property::IconHaloWidthTransition) {
+        setIconHaloWidthTransition(*transition);
         return nullopt;
     }
-    if (name == "icon-translate-anchor-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setIconTranslateAnchorTransition(*transition);
+    
+    if (property == Property::IconHaloBlurTransition) {
+        setIconHaloBlurTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-opacity") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextOpacity(*typedValue);
+    if (property == Property::IconTranslateTransition) {
+        setIconTranslateTransition(*transition);
         return nullopt;
     }
-    if (name == "text-opacity-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
-        setTextOpacityTransition(*transition);
+    
+    if (property == Property::IconTranslateAnchorTransition) {
+        setIconTranslateAnchorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextColor(*typedValue);
+    if (property == Property::TextOpacityTransition) {
+        setTextOpacityTransition(*transition);
         return nullopt;
     }
-    if (name == "text-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    
+    if (property == Property::TextColorTransition) {
         setTextColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-halo-color") {
-        Error error;
-        optional<PropertyValue<Color>> typedValue = convert<PropertyValue<Color>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextHaloColor(*typedValue);
-        return nullopt;
-    }
-    if (name == "text-halo-color-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::TextHaloColorTransition) {
         setTextHaloColorTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-halo-width") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextHaloWidth(*typedValue);
-        return nullopt;
-    }
-    if (name == "text-halo-width-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::TextHaloWidthTransition) {
         setTextHaloWidthTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-halo-blur") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextHaloBlur(*typedValue);
-        return nullopt;
-    }
-    if (name == "text-halo-blur-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::TextHaloBlurTransition) {
         setTextHaloBlurTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-translate") {
-        Error error;
-        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextTranslate(*typedValue);
-        return nullopt;
-    }
-    if (name == "text-translate-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::TextTranslateTransition) {
         setTextTranslateTransition(*transition);
         return nullopt;
     }
     
-    if (name == "text-translate-anchor") {
-        Error error;
-        optional<PropertyValue<TranslateAnchorType>> typedValue = convert<PropertyValue<TranslateAnchorType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
-        }
-
-        setTextTranslateAnchor(*typedValue);
-        return nullopt;
-    }
-    if (name == "text-translate-anchor-transition") {
-        Error error;
-        optional<TransitionOptions> transition = convert<TransitionOptions>(value, error);
-        if (!transition) {
-            return error;
-        }
-
+    if (property == Property::TextTranslateAnchorTransition) {
         setTextTranslateAnchorTransition(*transition);
         return nullopt;
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
@@ -1375,403 +1447,558 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
         return nullopt;
     }
 
+    enum class Property {
+        Unknown,
+        SymbolPlacement,
+        SymbolSpacing,
+        SymbolAvoidEdges,
+        IconAllowOverlap,
+        IconIgnorePlacement,
+        IconOptional,
+        IconRotationAlignment,
+        IconSize,
+        IconTextFit,
+        IconTextFitPadding,
+        IconImage,
+        IconRotate,
+        IconPadding,
+        IconKeepUpright,
+        IconOffset,
+        IconAnchor,
+        IconPitchAlignment,
+        TextPitchAlignment,
+        TextRotationAlignment,
+        TextField,
+        TextFont,
+        TextSize,
+        TextMaxWidth,
+        TextLineHeight,
+        TextLetterSpacing,
+        TextJustify,
+        TextAnchor,
+        TextMaxAngle,
+        TextRotate,
+        TextPadding,
+        TextKeepUpright,
+        TextTransform,
+        TextOffset,
+        TextAllowOverlap,
+        TextIgnorePlacement,
+        TextOptional,
+    };
+
+    Property property = Property::Unknown;
+    switch (util::hashFNV1a(name.c_str())) {
     
-    if (name == "symbol-placement") {
-        Error error;
-        optional<PropertyValue<SymbolPlacementType>> typedValue = convert<PropertyValue<SymbolPlacementType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("symbol-placement"):
+        if (name == "symbol-placement") {
+            property = Property::SymbolPlacement;
         }
-
-        setSymbolPlacement(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "symbol-spacing") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("symbol-spacing"):
+        if (name == "symbol-spacing") {
+            property = Property::SymbolSpacing;
         }
-
-        setSymbolSpacing(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "symbol-avoid-edges") {
-        Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("symbol-avoid-edges"):
+        if (name == "symbol-avoid-edges") {
+            property = Property::SymbolAvoidEdges;
         }
-
-        setSymbolAvoidEdges(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-allow-overlap") {
-        Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-allow-overlap"):
+        if (name == "icon-allow-overlap") {
+            property = Property::IconAllowOverlap;
         }
-
-        setIconAllowOverlap(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-ignore-placement") {
-        Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-ignore-placement"):
+        if (name == "icon-ignore-placement") {
+            property = Property::IconIgnorePlacement;
         }
-
-        setIconIgnorePlacement(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-optional") {
-        Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-optional"):
+        if (name == "icon-optional") {
+            property = Property::IconOptional;
         }
-
-        setIconOptional(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-rotation-alignment") {
-        Error error;
-        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-rotation-alignment"):
+        if (name == "icon-rotation-alignment") {
+            property = Property::IconRotationAlignment;
         }
-
-        setIconRotationAlignment(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-size") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-size"):
+        if (name == "icon-size") {
+            property = Property::IconSize;
         }
-
-        setIconSize(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-text-fit") {
-        Error error;
-        optional<PropertyValue<IconTextFitType>> typedValue = convert<PropertyValue<IconTextFitType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-text-fit"):
+        if (name == "icon-text-fit") {
+            property = Property::IconTextFit;
         }
-
-        setIconTextFit(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-text-fit-padding") {
-        Error error;
-        optional<PropertyValue<std::array<float, 4>>> typedValue = convert<PropertyValue<std::array<float, 4>>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-text-fit-padding"):
+        if (name == "icon-text-fit-padding") {
+            property = Property::IconTextFitPadding;
         }
-
-        setIconTextFitPadding(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-image") {
-        Error error;
-        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, true, true);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-image"):
+        if (name == "icon-image") {
+            property = Property::IconImage;
         }
-
-        setIconImage(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-rotate") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-rotate"):
+        if (name == "icon-rotate") {
+            property = Property::IconRotate;
         }
-
-        setIconRotate(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-padding") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-padding"):
+        if (name == "icon-padding") {
+            property = Property::IconPadding;
         }
-
-        setIconPadding(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-keep-upright") {
-        Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-keep-upright"):
+        if (name == "icon-keep-upright") {
+            property = Property::IconKeepUpright;
         }
-
-        setIconKeepUpright(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-offset") {
-        Error error;
-        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-offset"):
+        if (name == "icon-offset") {
+            property = Property::IconOffset;
         }
-
-        setIconOffset(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-anchor") {
-        Error error;
-        optional<PropertyValue<SymbolAnchorType>> typedValue = convert<PropertyValue<SymbolAnchorType>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-anchor"):
+        if (name == "icon-anchor") {
+            property = Property::IconAnchor;
         }
-
-        setIconAnchor(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "icon-pitch-alignment") {
-        Error error;
-        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("icon-pitch-alignment"):
+        if (name == "icon-pitch-alignment") {
+            property = Property::IconPitchAlignment;
         }
-
-        setIconPitchAlignment(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "text-pitch-alignment") {
-        Error error;
-        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("text-pitch-alignment"):
+        if (name == "text-pitch-alignment") {
+            property = Property::TextPitchAlignment;
         }
-
-        setTextPitchAlignment(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "text-rotation-alignment") {
-        Error error;
-        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("text-rotation-alignment"):
+        if (name == "text-rotation-alignment") {
+            property = Property::TextRotationAlignment;
         }
-
-        setTextRotationAlignment(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "text-field") {
-        Error error;
-        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, true, true);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("text-field"):
+        if (name == "text-field") {
+            property = Property::TextField;
         }
-
-        setTextField(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "text-font") {
-        Error error;
-        optional<PropertyValue<std::vector<std::string>>> typedValue = convert<PropertyValue<std::vector<std::string>>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("text-font"):
+        if (name == "text-font") {
+            property = Property::TextFont;
         }
-
-        setTextFont(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "text-size") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("text-size"):
+        if (name == "text-size") {
+            property = Property::TextSize;
         }
-
-        setTextSize(*typedValue);
-        return nullopt;
-    }
+        break;
     
-    if (name == "text-max-width") {
-        Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
-        if (!typedValue) {
-            return error;
+    case util::hashFNV1a("text-max-width"):
+        if (name == "text-max-width") {
+            property = Property::TextMaxWidth;
+        }
+        break;
+    
+    case util::hashFNV1a("text-line-height"):
+        if (name == "text-line-height") {
+            property = Property::TextLineHeight;
+        }
+        break;
+    
+    case util::hashFNV1a("text-letter-spacing"):
+        if (name == "text-letter-spacing") {
+            property = Property::TextLetterSpacing;
+        }
+        break;
+    
+    case util::hashFNV1a("text-justify"):
+        if (name == "text-justify") {
+            property = Property::TextJustify;
+        }
+        break;
+    
+    case util::hashFNV1a("text-anchor"):
+        if (name == "text-anchor") {
+            property = Property::TextAnchor;
+        }
+        break;
+    
+    case util::hashFNV1a("text-max-angle"):
+        if (name == "text-max-angle") {
+            property = Property::TextMaxAngle;
+        }
+        break;
+    
+    case util::hashFNV1a("text-rotate"):
+        if (name == "text-rotate") {
+            property = Property::TextRotate;
+        }
+        break;
+    
+    case util::hashFNV1a("text-padding"):
+        if (name == "text-padding") {
+            property = Property::TextPadding;
+        }
+        break;
+    
+    case util::hashFNV1a("text-keep-upright"):
+        if (name == "text-keep-upright") {
+            property = Property::TextKeepUpright;
+        }
+        break;
+    
+    case util::hashFNV1a("text-transform"):
+        if (name == "text-transform") {
+            property = Property::TextTransform;
+        }
+        break;
+    
+    case util::hashFNV1a("text-offset"):
+        if (name == "text-offset") {
+            property = Property::TextOffset;
+        }
+        break;
+    
+    case util::hashFNV1a("text-allow-overlap"):
+        if (name == "text-allow-overlap") {
+            property = Property::TextAllowOverlap;
+        }
+        break;
+    
+    case util::hashFNV1a("text-ignore-placement"):
+        if (name == "text-ignore-placement") {
+            property = Property::TextIgnorePlacement;
+        }
+        break;
+    
+    case util::hashFNV1a("text-optional"):
+        if (name == "text-optional") {
+            property = Property::TextOptional;
         }
+        break;
+    
+    }
 
-        setTextMaxWidth(*typedValue);
-        return nullopt;
+    if (property == Property::Unknown) {
+        return Error { "layer doesn't support this property" };
     }
-    
-    if (name == "text-line-height") {
+
+        
+    if (property == Property::SymbolPlacement) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        optional<PropertyValue<SymbolPlacementType>> typedValue = convert<PropertyValue<SymbolPlacementType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextLineHeight(*typedValue);
+        
+        setSymbolPlacement(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "text-letter-spacing") {
+    if (property == Property::SymbolSpacing || property == Property::IconPadding || property == Property::TextLineHeight || property == Property::TextMaxAngle || property == Property::TextPadding) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextLetterSpacing(*typedValue);
-        return nullopt;
+        
+        if (property == Property::SymbolSpacing) {
+            setSymbolSpacing(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconPadding) {
+            setIconPadding(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextLineHeight) {
+            setTextLineHeight(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextMaxAngle) {
+            setTextMaxAngle(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextPadding) {
+            setTextPadding(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-justify") {
+    if (property == Property::SymbolAvoidEdges || property == Property::IconAllowOverlap || property == Property::IconIgnorePlacement || property == Property::IconOptional || property == Property::IconKeepUpright || property == Property::TextKeepUpright || property == Property::TextAllowOverlap || property == Property::TextIgnorePlacement || property == Property::TextOptional) {
         Error error;
-        optional<PropertyValue<TextJustifyType>> typedValue = convert<PropertyValue<TextJustifyType>>(value, error, true, false);
+        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextJustify(*typedValue);
-        return nullopt;
+        
+        if (property == Property::SymbolAvoidEdges) {
+            setSymbolAvoidEdges(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconAllowOverlap) {
+            setIconAllowOverlap(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconIgnorePlacement) {
+            setIconIgnorePlacement(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconOptional) {
+            setIconOptional(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconKeepUpright) {
+            setIconKeepUpright(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextKeepUpright) {
+            setTextKeepUpright(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextAllowOverlap) {
+            setTextAllowOverlap(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextIgnorePlacement) {
+            setTextIgnorePlacement(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextOptional) {
+            setTextOptional(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-anchor") {
+    if (property == Property::IconRotationAlignment || property == Property::IconPitchAlignment || property == Property::TextPitchAlignment || property == Property::TextRotationAlignment) {
         Error error;
-        optional<PropertyValue<SymbolAnchorType>> typedValue = convert<PropertyValue<SymbolAnchorType>>(value, error, true, false);
+        optional<PropertyValue<AlignmentType>> typedValue = convert<PropertyValue<AlignmentType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextAnchor(*typedValue);
-        return nullopt;
+        
+        if (property == Property::IconRotationAlignment) {
+            setIconRotationAlignment(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconPitchAlignment) {
+            setIconPitchAlignment(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextPitchAlignment) {
+            setTextPitchAlignment(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextRotationAlignment) {
+            setTextRotationAlignment(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-max-angle") {
+    if (property == Property::IconSize || property == Property::IconRotate || property == Property::TextSize || property == Property::TextMaxWidth || property == Property::TextLetterSpacing || property == Property::TextRotate) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextMaxAngle(*typedValue);
-        return nullopt;
+        
+        if (property == Property::IconSize) {
+            setIconSize(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::IconRotate) {
+            setIconRotate(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextSize) {
+            setTextSize(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextMaxWidth) {
+            setTextMaxWidth(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextLetterSpacing) {
+            setTextLetterSpacing(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextRotate) {
+            setTextRotate(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-rotate") {
+    if (property == Property::IconTextFit) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, true, false);
+        optional<PropertyValue<IconTextFitType>> typedValue = convert<PropertyValue<IconTextFitType>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextRotate(*typedValue);
+        
+        setIconTextFit(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "text-padding") {
+    if (property == Property::IconTextFitPadding) {
         Error error;
-        optional<PropertyValue<float>> typedValue = convert<PropertyValue<float>>(value, error, false, false);
+        optional<PropertyValue<std::array<float, 4>>> typedValue = convert<PropertyValue<std::array<float, 4>>>(value, error, false, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextPadding(*typedValue);
+        
+        setIconTextFitPadding(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "text-keep-upright") {
+    if (property == Property::IconImage || property == Property::TextField) {
         Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        optional<PropertyValue<std::string>> typedValue = convert<PropertyValue<std::string>>(value, error, true, true);
         if (!typedValue) {
             return error;
         }
-
-        setTextKeepUpright(*typedValue);
-        return nullopt;
+        
+        if (property == Property::IconImage) {
+            setIconImage(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextField) {
+            setTextField(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-transform") {
+    if (property == Property::IconOffset || property == Property::TextOffset) {
         Error error;
-        optional<PropertyValue<TextTransformType>> typedValue = convert<PropertyValue<TextTransformType>>(value, error, true, false);
+        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextTransform(*typedValue);
-        return nullopt;
+        
+        if (property == Property::IconOffset) {
+            setIconOffset(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextOffset) {
+            setTextOffset(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-offset") {
+    if (property == Property::IconAnchor || property == Property::TextAnchor) {
         Error error;
-        optional<PropertyValue<std::array<float, 2>>> typedValue = convert<PropertyValue<std::array<float, 2>>>(value, error, true, false);
+        optional<PropertyValue<SymbolAnchorType>> typedValue = convert<PropertyValue<SymbolAnchorType>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextOffset(*typedValue);
-        return nullopt;
+        
+        if (property == Property::IconAnchor) {
+            setIconAnchor(*typedValue);
+            return nullopt;
+        }
+        
+        if (property == Property::TextAnchor) {
+            setTextAnchor(*typedValue);
+            return nullopt;
+        }
+        
     }
     
-    if (name == "text-allow-overlap") {
+    if (property == Property::TextFont) {
         Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        optional<PropertyValue<std::vector<std::string>>> typedValue = convert<PropertyValue<std::vector<std::string>>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextAllowOverlap(*typedValue);
+        
+        setTextFont(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "text-ignore-placement") {
+    if (property == Property::TextJustify) {
         Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        optional<PropertyValue<TextJustifyType>> typedValue = convert<PropertyValue<TextJustifyType>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextIgnorePlacement(*typedValue);
+        
+        setTextJustify(*typedValue);
         return nullopt;
+        
     }
     
-    if (name == "text-optional") {
+    if (property == Property::TextTransform) {
         Error error;
-        optional<PropertyValue<bool>> typedValue = convert<PropertyValue<bool>>(value, error, false, false);
+        optional<PropertyValue<TextTransformType>> typedValue = convert<PropertyValue<TextTransformType>>(value, error, true, false);
         if (!typedValue) {
             return error;
         }
-
-        setTextOptional(*typedValue);
+        
+        setTextTransform(*typedValue);
         return nullopt;
+        
     }
     
+
     return Error { "layer doesn't support this property" };
 }
 
diff --git a/src/mbgl/util/fnv_hash.hpp b/src/mbgl/util/fnv_hash.hpp
new file mode 100644
index 0000000000..87d4661c56
--- /dev/null
+++ b/src/mbgl/util/fnv_hash.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace mbgl {
+namespace util {
+
+inline constexpr uint64_t hashFNV1a(const char * str, uint64_t value = 0xcbf29ce484222325) {
+    return str[0] ? hashFNV1a(str + 1, (value ^ uint64_t(str[0])) * 0x100000001b3) : value;
+}
+
+} // end namespace util
+} // end namespace mbgl