parsing_context.hpp

Go to the documentation of this file.

#pragma once
 
#include <mbgl/util/string.hpp>
#include <mbgl/style/expression/type.hpp>
#include <mbgl/style/conversion.hpp>
 
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include <optional>
 
namespace mbgl {
namespace style {
namespace expression {
 
class Expression;
 
struct ParsingError {
    std::string message;
    std::string key;
    bool operator==(const ParsingError& rhs) const { return message == rhs.message && key == rhs.key; }
};
 
using ParseResult = std::optional<std::unique_ptr<Expression>>;
 
namespace detail {
 
class Scope {
public:
    Scope(const std::map<std::string, std::shared_ptr<Expression>>& bindings_, std::shared_ptr<Scope> parent_ = nullptr) :
        bindings(bindings_),
        parent(std::move(parent_))
    {}
 
    const std::map<std::string, std::shared_ptr<Expression>>& bindings;
    std::shared_ptr<Scope> parent;
    
    std::optional<std::shared_ptr<Expression>> get(const std::string& name) {
        auto it = bindings.find(name);
        if (it != bindings.end()) {
            return {it->second};
        } else if (parent) {
            return parent->get(name);
        } else {
            return std::optional<std::shared_ptr<Expression>>();
        }
    }
};
 
} // namespace detail
 
enum class TypeAnnotationOption {
    coerce,
    assert,
    omit
};
 
class ParsingContext {
public:
    ParsingContext() : errors(std::make_shared<std::vector<ParsingError>>()) {}
    ParsingContext(std::string key_) : key(std::move(key_)), errors(std::make_shared<std::vector<ParsingError>>()) {}
    explicit ParsingContext(type::Type expected_)
        : expected(std::move(expected_)),
          errors(std::make_shared<std::vector<ParsingError>>())
    {}
    ParsingContext(ParsingContext&&) = default;
    
    ParsingContext(const ParsingContext&) = delete;
    ParsingContext& operator=(const ParsingContext&) = delete;
 
    std::string getKey() const { return key; }
    std::optional<type::Type> getExpected() const { return expected; }
    const std::vector<ParsingError>& getErrors() const { return *errors; }
    std::string getCombinedErrors() const;
 
    ParseResult parseExpression(const mbgl::style::conversion::Convertible& value,
                                const std::optional<TypeAnnotationOption>& = std::nullopt);
 
    ParseResult parseLayerPropertyExpression(const mbgl::style::conversion::Convertible& value);
 
    ParseResult parse(const mbgl::style::conversion::Convertible&,
                      std::size_t,
                      std::optional<type::Type> = std::nullopt,
                      const std::optional<TypeAnnotationOption>& = std::nullopt);
 
    ParseResult parse(const mbgl::style::conversion::Convertible&,
                      std::size_t index,
                      std::optional<type::Type>,
                      const std::map<std::string, std::shared_ptr<Expression>>&);
 
    std::optional<std::string> checkType(const type::Type& t);
 
    std::optional<std::shared_ptr<Expression>> getBinding(const std::string& name) {
        if (!scope) return std::optional<std::shared_ptr<Expression>>();
        return scope->get(name);
    }
 
    void error(std::string message) { errors->push_back({std::move(message), key}); }
 
    void error(std::string message, std::size_t child) {
        errors->push_back({std::move(message), key + "[" + util::toString(child) + "]"});
    }
    
    void error(std::string message, std::size_t child, std::size_t grandchild) {
        errors->push_back(
            {std::move(message), key + "[" + util::toString(child) + "][" + util::toString(grandchild) + "]"});
    }
    
    void appendErrors(ParsingContext&& ctx) {
        errors->reserve(errors->size() + ctx.errors->size());
        std::move(ctx.errors->begin(), ctx.errors->end(), std::inserter(*errors, errors->end()));
        ctx.errors->clear();
    }
    
    void clearErrors() {
        errors->clear();
    }
    
private:
    ParsingContext(std::string key_,
                   std::shared_ptr<std::vector<ParsingError>> errors_,
                   std::optional<type::Type> expected_,
                   std::shared_ptr<detail::Scope> scope_)
        : key(std::move(key_)),
          expected(std::move(expected_)),
          scope(std::move(scope_)),
        errors(std::move(errors_))
    {}
    
    
    ParseResult parse(const mbgl::style::conversion::Convertible& value, const std::optional<TypeAnnotationOption>& = std::nullopt);
 
    std::string key;
    std::optional<type::Type> expected;
    std::shared_ptr<detail::Scope> scope;
    std::shared_ptr<std::vector<ParsingError>> errors;
};
 
bool isExpression(const std::string&);
 
} // namespace expression
} // namespace style
} // namespace mbgl