reserve when incoming size is known

8 files changed, 18 insertions, 3 deletions

diff --git a/src/mbgl/style/expression/assertion.cpp b/src/mbgl/style/expression/assertion.cpp
index 0ff59a268c..7e1ef95e7a 100644
--- a/src/mbgl/style/expression/assertion.cpp
+++ b/src/mbgl/style/expression/assertion.cpp
@@ -25,6 +25,7 @@ ParseResult Assertion::parse(const mbgl::style::conversion::Convertible& value,
     assert(it != types.end());
     
     std::vector<std::unique_ptr<Expression>> parsed;
+    parsed.reserve(length - 1);
     for (std::size_t i = 1; i < length; i++) {
         ParseResult input = ctx.concat(i, {type::Value}).parse(arrayMember(value, i));
         if (!input) return ParseResult();
diff --git a/src/mbgl/style/expression/boolean_operator.cpp b/src/mbgl/style/expression/boolean_operator.cpp
index b0fcc8fd9a..6c184ef173 100644
--- a/src/mbgl/style/expression/boolean_operator.cpp
+++ b/src/mbgl/style/expression/boolean_operator.cpp
@@ -41,7 +41,8 @@ ParseResult parseBooleanOp(const mbgl::style::conversion::Convertible& value, Pa
     auto length = arrayLength(value);
  
     std::vector<std::unique_ptr<Expression>> parsedInputs;
-
+    
+    parsedInputs.reserve(length - 1);
     for (std::size_t i = 1; i < length; i++) {
         auto parsed = ctx.concat(i, {type::Boolean}).parse(arrayMember(value, i));
         if (!parsed) {
diff --git a/src/mbgl/style/expression/case.cpp b/src/mbgl/style/expression/case.cpp
index 68a940d06d..4438af8511 100644
--- a/src/mbgl/style/expression/case.cpp
+++ b/src/mbgl/style/expression/case.cpp
@@ -48,6 +48,7 @@ ParseResult Case::parse(const mbgl::style::conversion::Convertible& value, Parsi
     }
 
     std::vector<Case::Branch> branches;
+    branches.reserve((length - 2) / 2);
     for (size_t i = 1; i + 1 < length; i += 2) {
         auto test = ctx.concat(i, {type::Boolean}).parse(arrayMember(value, i));
         if (!test) {
diff --git a/src/mbgl/style/expression/coalesce.cpp b/src/mbgl/style/expression/coalesce.cpp
index 22e15066bd..479aae1a1a 100644
--- a/src/mbgl/style/expression/coalesce.cpp
+++ b/src/mbgl/style/expression/coalesce.cpp
@@ -28,12 +28,13 @@ ParseResult Coalesce::parse(const mbgl::style::conversion::Convertible& value, P
         return ParseResult();
     }
  
-    Coalesce::Args args;
     optional<type::Type> outputType;
     if (ctx.expected && *ctx.expected != type::Value) {
         outputType = ctx.expected;
     }
 
+    Coalesce::Args args;
+    args.reserve(length - 1);
     for (std::size_t i = 1; i < length; i++) {
         auto parsed = ctx.concat(i, outputType).parse(arrayMember(value, i));
         if (!parsed) {
diff --git a/src/mbgl/style/expression/coercion.cpp b/src/mbgl/style/expression/coercion.cpp
index c29a42c218..b4ac98def4 100644
--- a/src/mbgl/style/expression/coercion.cpp
+++ b/src/mbgl/style/expression/coercion.cpp
@@ -98,6 +98,7 @@ ParseResult Coercion::parse(const mbgl::style::conversion::Convertible& value, P
     assert(it != types.end());
     
     std::vector<std::unique_ptr<Expression>> parsed;
+    parsed.reserve(length - 1);
     for (std::size_t i = 1; i < length; i++) {
         ParseResult input = ctx.concat(i, {type::Value}).parse(arrayMember(value, i));
         if (!input) return ParseResult();
diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp
index 3e8ebcf7b2..f538c64df4 100644
--- a/src/mbgl/style/expression/compound_expression.cpp
+++ b/src/mbgl/style/expression/compound_expression.cpp
@@ -91,6 +91,7 @@ struct Signature<R (const Varargs<T>&)> : SignatureBase {
     
     EvaluationResult apply(const EvaluationParameters& evaluationParameters, const Args& args) const {
         Varargs<T> evaluated;
+        evaluated.reserve(args.size());
         for (const auto& arg : args) {
             const EvaluationResult evaluatedArg = arg->evaluate(evaluationParameters);
             if(!evaluatedArg) return evaluatedArg.error();
@@ -448,7 +449,6 @@ ParseResult parseCompoundExpression(const std::string name, const mbgl::style::c
     }
     const CompoundExpressionRegistry::Definition& definition = it->second;
     
-    std::vector<std::unique_ptr<Expression>> args;
     auto length = arrayLength(value);
 
     // Check if we have a single signature with the correct number of
@@ -470,6 +470,8 @@ ParseResult parseCompoundExpression(const std::string name, const mbgl::style::c
     }
 
     // parse subexpressions first
+    std::vector<std::unique_ptr<Expression>> args;
+    args.reserve(length - 1);
     for (std::size_t i = 1; i < length; i++) {
         optional<type::Type> expected;
         
diff --git a/src/mbgl/style/expression/match.cpp b/src/mbgl/style/expression/match.cpp
index a420799b7a..b058e09bf0 100644
--- a/src/mbgl/style/expression/match.cpp
+++ b/src/mbgl/style/expression/match.cpp
@@ -120,6 +120,8 @@ static ParseResult create(type::Type outputType,
     typename Match<T>::Branches typedBranches;
     
     std::size_t index = 2;
+
+    typedBranches.reserve(branches.size());
     for (std::pair<std::vector<InputType>,
                    std::unique_ptr<Expression>>& pair : branches) {
         std::shared_ptr<Expression> result = std::move(pair.second);
@@ -169,6 +171,7 @@ ParseResult parseMatch(const mbgl::style::conversion::Convertible& value, Parsin
     std::vector<std::pair<std::vector<InputType>,
                           std::unique_ptr<Expression>>> branches;
 
+    branches.reserve((length - 3) / 2);
     for (size_t i = 2; i + 1 < length; i += 2) {
         const auto& label = arrayMember(value, i);
 
@@ -182,6 +185,7 @@ ParseResult parseMatch(const mbgl::style::conversion::Convertible& value, Parsin
                 return ParseResult();
             }
             
+            labels.reserve(groupLength);
             for (size_t j = 0; j < groupLength; j++) {
                 const optional<InputType> inputValue = parseInputValue(arrayMember(label, j), ctx.concat(i, inputType), inputType);
                 if (!inputValue) {
diff --git a/src/mbgl/style/expression/value.cpp b/src/mbgl/style/expression/value.cpp
index 6be936c299..6150e5e4bb 100644
--- a/src/mbgl/style/expression/value.cpp
+++ b/src/mbgl/style/expression/value.cpp
@@ -74,6 +74,7 @@ std::string stringify(const Value& value) {
 struct FromMBGLValue {
     Value operator()(const std::vector<mbgl::Value>& v) {
         std::vector<Value> result;
+        result.reserve(v.size());
         for(const auto& item : v) {
             result.emplace_back(toExpressionValue(item));
         }
@@ -82,6 +83,7 @@ struct FromMBGLValue {
     
     Value operator()(const std::unordered_map<std::string, mbgl::Value>& v) {
         std::unordered_map<std::string, Value> result;
+        result.reserve(v.size());
         for(const auto& entry : v) {
             result.emplace(entry.first, toExpressionValue(entry.second));
         }
@@ -123,6 +125,7 @@ optional<float> ValueConverter<float>::fromExpressionValue(const Value& value) {
 template <typename T, typename Container>
 std::vector<Value> toArrayValue(const Container& value) {
     std::vector<Value> result;
+    result.reserve(value.size());
     for (const T& item : value) {
         result.push_back(ValueConverter<T>::toExpressionValue(item));
     }
@@ -166,6 +169,7 @@ optional<std::vector<T>> ValueConverter<std::vector<T>>::fromExpressionValue(con
     return value.match(
         [&] (const std::vector<Value>& v) -> optional<std::vector<T>> {
             std::vector<T> result;
+            result.reserve(v.size());
             for(const Value& item : v) {
                 optional<T> convertedItem = ValueConverter<T>::fromExpressionValue(item);
                 if (!convertedItem) {